张开放
张开放

〖TensorFlow2.0笔记26〗YOLOV2目标检测算法以及实战！

YOLOV2目标检测算法以及实战！

文章目录

    • 一. YOLOV2算法介绍
      • 1.1. YOLOV2提升1
      • 1.2. YOLOV2提升2
      • 1.3. YOLOV2提升3
      • 1.4. YOLOV2总结
    • 二. YOLOV2算法实战之Dataset
      • 2.1. 数据集构成
      • 2.2. 解析图像的XML文件
      • 2.3. 构建DB(拼接成Tensorflow的Dataset对象)
      • 2.4. 可视化DB(一张图像)
      • 2.5. 数据增强(data augumentation)
    • 三. YOLOV2算法实战之Compose labels
      • 3.1. GT box介绍
      • 3.2. 批量GT box合并以及批量Generator
      • 3.3. GT box可视化
    • 四. YOLOV2算法实战之Model
      • 4.1. Darknet-19网络结构
      • 4.2. 网络初始化
      • 4.3. 网络输出可视化
    • 五. YOLOV2算法实战之Loss

一. YOLOV2算法介绍

1.1. YOLOV2提升1

Yolov2相对Yolov1的提升点之一：

〖TensorFlow2.0笔记26〗YOLOV2目标检测算法以及实战！_第1张图片

1.2. YOLOV2提升2

Yolov2相对Yolov1的提升点之二：

〖TensorFlow2.0笔记26〗YOLOV2目标检测算法以及实战！_第2张图片
〖TensorFlow2.0笔记26〗YOLOV2目标检测算法以及实战！_第3张图片
〖TensorFlow2.0笔记26〗YOLOV2目标检测算法以及实战！_第4张图片
〖TensorFlow2.0笔记26〗YOLOV2目标检测算法以及实战！_第5张图片

Which anchor is the best?

〖TensorFlow2.0笔记26〗YOLOV2目标检测算法以及实战！_第6张图片

1.3. YOLOV2提升3

  • Yolov2相对Yolov1的提升点之三：
〖TensorFlow2.0笔记26〗YOLOV2目标检测算法以及实战！_第7张图片

1.4. YOLOV2总结

Yolov2相对Yolov1的有3个改进

  • 主干网络的改进；
  • anchor box共5个标杆的改进；
  • 输出形式的改进，这里输出的是一个偏移。体现x,y坐标上就是x,y坐标的一个偏移。体现在w,h宽高就是w,h宽高的倍率的差距；
〖TensorFlow2.0笔记26〗YOLOV2目标检测算法以及实战！_第8张图片
  • 注意： 我们在构造Target的过程中，首先我们给了5个标杆anchor box，我们只写真实目标框和5个anchor box的IOU最高的那个，其它的还是设置为0，如上图所示。
  • Yolov2的测试：

二. YOLOV2算法实战之Dataset

2.1. 数据集构成

-----data #数据集目录
----------train #训练集(116个样本)
---------------annotation
---------------image
----------val #测试集(4个样本)
---------------annotation
---------------image

训练集(有2个类别甜菜和杂草)：

验证集：

2.2. 解析图像的XML文件

#%%
# 温馨提示：目标检测是非常非常复杂的任务，建议使用6GB以上的显卡运行！ 
import os,glob 
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import numpy as np 
import tensorflow as tf 
from tensorflow import keras 

tf.random.set_seed(2234)
np.random.seed(2234)

# Shift+Enter可以运行(这里使用的VScode编辑器)
# tf2
# %%
print(tf.__version__)
print(tf.test.is_gpu_available())
# %%
import xml.etree.ElementTree as ET                      #这个库专门用来解析xml文件的。

def parse_annotation(img_dir, ann_dir, labels):
    # img_dir: image path
    # ann_dir: annotation xml file path
    # labels: ('sugarweet', 'weed')杂草和甜菜。
    # parse annotation info from xml file
    """
     根节点
	X2-10-0.png
	
		512
		512
		3
	
    
        sugarbeet
        
            1
            250
            53
            289
        
    
    ....还有object

    """
    imgs_info = []

    max_boxes = 0 # 保存当前数据集中，objects最多的一个数字。
    # for each annotation xml file遍历
    for ann in os.listdir(ann_dir): 
        tree = ET.parse(os.path.join(ann_dir, ann))  # xml文件变为tree对象。

        img_info = dict()        # img_info保存到字典中去
        boxes_counter = 0        # 记录当前图片的box数量。
        img_info['object'] = []  # 对xml对象节点进行遍历，
        for elem in tree.iter():
            if 'filename' in elem.tag:  # 如果当前节点的名字有filename
                img_info['filename'] = os.path.join(img_dir,elem.text)
            if 'width' in elem.tag:
                img_info['width'] = int(elem.text)
                assert img_info['width'] == 512 # 这里我们做了一个简化，我们所有的图片都是512*512，真实场景中需要把图片缩放到一致。
            if 'height' in elem.tag:
                img_info['height'] = int(elem.text)
                assert img_info['height'] == 512

            if 'object' in elem.tag or 'part' in elem.tag:
                # x1-y1-x2-y2-label，前4个box,左边，最后一个类别。
                object_info = [0,0,0,0,0]
                boxes_counter += 1
                for attr in list(elem):  # 遍历当前对象的子节点。
                    if 'name' in attr.tag:
                        label = labels.index(attr.text) + 1 #对类别编码，sugarweet返回1，weet返回2。目标检测一般从1开始，0留个背景信息。
                        object_info[4] = label
                    if 'bndbox' in attr.tag:
                        for pos in list(attr):
                            if 'xmin' in pos.tag:
                                object_info[0] = int(pos.text)
                            if 'ymin' in pos.tag:
                                object_info[1] = int(pos.text)
                            if 'xmax' in pos.tag:
                                object_info[2] = int(pos.text)
                            if 'ymax' in pos.tag:
                                object_info[3] = int(pos.text)
                img_info['object'].append(object_info)

        imgs_info.append(img_info) # filename, w/h/box_info

        # (N,5)=(max_objects_num, 5)
        if boxes_counter > max_boxes:
            max_boxes  = boxes_counter      # 比最大的max_boxes要打，刷新为最新的峰值。
    # the maximum boxes number is max_boxes，假设当前图片中最大的目标个数为40个。
    # [b, 40, 5] 创建numpy数组：张数，最多boxes,坐标加类别；这里直接写出来某一张图片最大的目标数字是40
    boxes = np.zeros([len(imgs_info), max_boxes, 5])  ################################### 初始化为全0
    print(boxes.shape)
    imgs = [] # filename list
    for i, img_info in enumerate(imgs_info):
        # 把每一张图片中的objects变为numpy类型的数组。[N,5]N为目标个数。
        img_boxes = np.array(img_info['object']) # 对列表封装成numpy类型。
        # overwrite the N boxes info
        boxes[i,:img_boxes.shape[0]] = img_boxes # 这里只写出boxes的前N列。
 
        imgs.append(img_info['filename'])        # 图片名字列表信息。

        print("图片名字：\n", img_info['filename'])
        print("object的boxes信息：\n", boxes[i,:5]) # 打印测试一下，依次打印当前图片名字，以及图片中objects的boxes信息。
        print("=======================================================================")
    # imgs: list of image path
    # boxes: [b,40,5]
    return imgs, boxes

# %%
obj_names = ('sugarbeet', 'weed')
imgs, boxes = parse_annotation('data/train/image', 'data/train/annotation', obj_names)




运行结果(部分)：




C:\Anaconda3\envs\vs_tf2\python.exe C:/zhang/codes/my_yolov2/main.py
2.0.0
True
(116, 40, 5)
图片名字：
 data/train/image\X-10-0.png
object的boxes信息：
 [[  1. 170.  75. 321.   1.]
 [112. 214. 232. 325.   1.]
 [256. 177. 370. 341.   1.]
 [452. 211. 512. 316.   1.]
 [466. 385. 488. 403.   2.]]
=======================================================================
图片名字：
 data/train/image\X-10-1.png
object的boxes信息：
 [[ 89. 206. 243. 317.   1.]
 [272. 213. 453. 372.   1.]
 [178.  85. 192. 100.   2.]
 [  0.   0.   0.   0.   0.]
 [  0.   0.   0.   0.   0.]]
=======================================================================
图片名字：
 data/train/image\X-110-0.png
object的boxes信息：
 [[233.  61. 250.  69.   2.]
 [  1. 153.  50. 292.   1.]
 [100. 164. 209. 317.   1.]
 [261. 167. 426. 304.   1.]
 [  0.   0.   0.   0.   0.]]
=======================================================================



2.3. 构建DB(拼接成Tensorflow的Dataset对象)


# 预处理函数,完成
def preprocess(img, img_boxes):
    # img      : string
    # img_boxes: [40, 5]
    x = tf.io.read_file(img)                        # 通过路径读取图像
    x = tf.image.decode_png(x, channels=3)          # 图像数值范围：0~255
    x = tf.image.convert_image_dtype(x, tf.float32) # 自动把数值压缩到：0~1
    return x, img_boxes

def get_dataset(img_dir, ann_dir, batchsz):
    # 这个目的是构建TensorFlow的Dataset对象。
    # imgs的shape: [b]; boxes shape: [b, 40, 5]
    imgs, boxes = parse_annotation('data/train/image', 'data/train/annotation', obj_names)
    db = tf.data.Dataset.from_tensor_slices((imgs, boxes)) # 构建数据集对象
    db = db.shuffle(1000).map(preprocess).batch(batchsz).repeat()
    print('db Images:', len(imgs))
    return db

train_db = get_dataset('data/train/image', 'data/train/annotation', 4)
print(train_db)





运行结果：




C:\Anaconda3\envs\vs_tf2\python.exe C:/zhang/codes/my_yolov2/main.py
2.0.0
True
boxes shape： (116, 40, 5)
db Images: 116
((None, None, None, 3), (None, 40, 5)), types: (tf.float32, tf.float64)>

Process finished with exit code 0



2.4. 可视化DB(一张图像)




注意： bounding box的2个坐标是左上角和右下角。




## 1.3 可视化DB,这里可视化一张
from matplotlib import pyplot as plt
from matplotlib import patches

def db_visualize(db):
    # db   shape: [b, 512, 512, 3]
    # imgs_boxes: [b, 40, 5]
    imgs, imgs_boxes = next(iter(db))
    img, img_boxes = imgs[0], imgs_boxes[0]
    f, ax1 = plt.subplots(1)  # 创建一张图
    ax1.imshow(img)          # 显示图片[512, 512, 3]
    for x1, y1, x2, y2, l in img_boxes: # [40, 5]，显示box
        x1, y1, x2, y2 = float(x1), float(y1), float(x2), float(y2) # 变为浮点数
        w = x2-x1
        h = y2-y1

        # 判断类别信息
        if l==1: # green for sugarweet
            color = (0, 1, 0) # 绿色
        elif l==2:
            color = (1, 0, 0) # 红色，RGB，因为是0~1的范围。
        else: # ignore invalid boxes
            break

        rect = patches.Rectangle((x1, y1), w, h, linewidth=2,
                                 edgecolor=color, facecolor='none') # 绘制矩形框，左上角坐标，长宽。
        ax1.add_patch(rect) # 添加矩形框到图像上面

# %%
db_visualize(train_db)
plt.show()





运行结果：





〖TensorFlow2.0笔记26〗YOLOV2目标检测算法以及实战！_第9张图片



2.5. 数据增强(data augumentation)




注意： 这里我们的数据集是比较少的，做数据增强有利于增加图片的数量，我们可以对图片旋转、添加噪声、视角变换、色彩度的变换。这里变换的时候和图片分类是不一样的，因为如何变换图片的类别信息是不变的，但是我们对于框的位置信息是发生变化的，例如图片旋转90度，框子也要跟着旋转90度。




# %%
# 1.4 数据增强模块
# 这个标准的库专门用来做数据增强的，而且支持目标检测box跟着旋转的操作，所以不需要自己写代码。
# 图片和框可以同时旋转。
import imgaug as ia
from imgaug import augmenters as iaa

def augmentation_generator(yolo_dataset):
    '''
    Augmented batch generator from a yolo dataset
    Parameters
    ----------
    - YOLO dataset

    Returns
    -------
    - augmented batch : tensor (shape : batch_size, IMAGE_W, IMAGE_H, 3)
        batch : tupple(images, annotations)
        batch[0] : images : tensor (shape : batch_size, IMAGE_W, IMAGE_H, 3)
        batch[1] : annotations : tensor (shape : batch_size, max annot, 5)
    '''
    for batch in yolo_dataset:
        # conversion tensor->numpy
        img = batch[0].numpy()
        boxes = batch[1].numpy()
        # conversion bbox numpy->ia object
        ia_boxes = []
        for i in range(img.shape[0]):
            ia_bbs = [ia.BoundingBox(x1=bb[0],
                                     y1=bb[1],
                                     x2=bb[2],
                                     y2=bb[3]) for bb in boxes[i]
                      if (bb[0] + bb[1] + bb[2] + bb[3] > 0)]
            ia_boxes.append(ia.BoundingBoxesOnImage(ia_bbs, shape=(512, 512)))
        # data augmentation
        seq = iaa.Sequential([
            iaa.Fliplr(0.5),
            iaa.Flipud(0.5),
            iaa.Multiply((0.4, 1.6)),  # change brightness
            # iaa.ContrastNormalization((0.5, 1.5)),
            # iaa.Affine(translate_px={"x": (-100,100), "y": (-100,100)}, scale=(0.7, 1.30))
        ])
        # seq = iaa.Sequential([])
        seq_det = seq.to_deterministic()
        img_aug = seq_det.augment_images(img)
        img_aug = np.clip(img_aug, 0, 1)
        boxes_aug = seq_det.augment_bounding_boxes(ia_boxes)
        # conversion ia object -> bbox numpy
        for i in range(img.shape[0]):
            boxes_aug[i] = boxes_aug[i].remove_out_of_image().clip_out_of_image()
            for j, bb in enumerate(boxes_aug[i].bounding_boxes):
                boxes[i, j, 0] = bb.x1
                boxes[i, j, 1] = bb.y1
                boxes[i, j, 2] = bb.x2
                boxes[i, j, 3] = bb.y2
        # conversion numpy->tensor
        batch = (tf.convert_to_tensor(img_aug), tf.convert_to_tensor(boxes))
        # batch = (img_aug, boxes)
        yield batch


# %%
aug_train_db = augmentation_generator(train_db)  # 数据增强后的aug_train_db，参数train_db没有做数据增强的。
db_visualize(aug_train_db)
plt.show()




〖TensorFlow2.0笔记26〗YOLOV2目标检测算法以及实战！_第10张图片



三. YOLOV2算法实战之Compose labels


3.1. GT box介绍




注意： 网络输出是  16 × 16 16 \times 16 16×16 的feature map，每个网格有  5 5 5 个anchor box，并且每个anchor box信息用长度为  7 7 7 的向量表示，所以输出格式为： [ b , 16 , 16 , 5 , 7 ] [b, 16, 16, 5, 7] [b,16,16,5,7]，它是一个  5 5 5 维的张量表示，这个长度为  7 7 7 的向量表示为中心点坐标  x , y x, y x,y，宽度和高度  w , h w, h w,h，置信度(这个网格有没有box的置信度)  c o n f conf conf，类别信息2类，共有  2 + 2 + 2 + 1 = 7 2+2+2+1=7 2+2+2+1=7。此外目标值Targe 也是相同shape的输出值，也是  [ b , 16 , 16 , 5 , 7 ] [b, 16, 16, 5, 7] [b,16,16,5,7] 这样  5 5 5 维的张量，但是实际中我们拿到的box是  [ b , 40 ， 5 ] [b, 40，5] [b,40，5] 这样的  3 3 3 维张量，所以我们接下来的工作就是完成我们实际拿到的box到Target目标值的转换。






这里  [ 40 , 5 ] [40,5] [40,5]，  x 1 − y 1 − x 2 − y 2 − l = > x − y − w − h − l x_1-y_1-x_2-y_2-l => x-y-w-h-l x1​−y1​−x2​−y2​−l=>x−y−w−h−l 的转换表示为如下，这里转换的目的是因为网络的输出也是预测中心点坐标，宽和高。不会预测左上角和右下角这2个坐标信息。





〖TensorFlow2.0笔记26〗YOLOV2目标检测算法以及实战！_第11张图片




〖TensorFlow2.0笔记26〗YOLOV2目标检测算法以及实战！_第12张图片



# %%我们先定义一组超参数
IMGSZ = 512     #图片大小
GRIDSZ = 16     #网格划分多少
ANCHORS = [0.57273, 0.677385, 1.87446, 2.06253, 3.33843, 5.47434, 7.88282, 3.52778, 9.77052, 9.16828] # 提供的5个anchor的宽和高。
ANCHORS_NUM = len(ANCHORS)//2


# %% 我们把每个图片的box信息写入到网格中间去。
def process_true_boxes(gt_boxes, anchors):
    # gt_boxes: [40,5]
    # 512//16=32,可以理解为从512*512的特征下采样到16*16的特征。
    scale = IMGSZ/GRIDSZ
    anchors = np.array(ANCHORS).reshape(ANCHORS_NUM, 2) # 封装成numpy数组    # [5,2]

    # mask for object 每个网格点是否有box中心点落在该区域
    detector_mask = np.zeros([GRIDSZ, GRIDSZ, 5, 1]) #5表示ANCHOR_NUM, 1表示当前网格点是否有真实的box落到该区域。
    #x-y-w-h-l
    matching_gt_box = np.zeros([GRIDSZ, GRIDSZ, 5, 5])
    # [40,5] x1-y1-x2-y2-l => x-y-w-h-l
    gt_boxes_grid = np.zeros(gt_boxes.shape)

    # DB: tensor => numpy 首先把tenosorflow中的转成numpy
    gt_boxes = gt_boxes.numpy()

    for i,box in enumerate(gt_boxes): # [40,5]
        # box: [5], x1-y1-x2-y2-l
        # 512大小映射到=> 16，所以这里需要除以一个倍率。
        x = ((box[0]+box[2])/2)/scale # 中心点坐标
        y = ((box[1]+box[3])/2)/scale # 中心点坐标
        w = (box[2] - box[0]) / scale # 宽
        h = (box[3] - box[1]) / scale # 高
        # [40,5] x-y-w-h-l
        gt_boxes_grid[i] = np.array([x,y,w,h,box[4]]) # 中心坐标，宽，高，类别

        if w*h > 0:        # valid box 这个位置是有box的。
            # 这里假设 x,y: 7.3, 6.8，这就代表在横坐标第8个格子，纵坐标第7个格子。
            ######### 这里需要主要对于当前区域的5个anchor我们不知道这5个哪个和真实的最接近。
            ######### 我们来计算交并比
            best_anchor = 0
            best_iou = 0
            for j in range(5):
                interct = np.minimum(w, anchors[j, 0]) * np.minimum(h, anchors[j, 1])
                union = w * h + (anchors[j, 0] * anchors[j, 1]) - interct
                iou = interct / union

                if iou > best_iou:  # best iou
                    best_anchor = j
                    best_iou = iou
                    # found the best anchors
            if best_iou > 0:  # 加一个判断
                x_coord = np.floor(x).astype(np.int32)  # 地板函数，取x的整数部分。找格子
                y_coord = np.floor(y).astype(np.int32)  # 也是地板函数
                # 这里注意一下张量的组织方式是：[b,h,w,5,1]，先在哪一个网格对应的位置有box写上1(重合率最高的那个anchor)；
                # 也就是其他anchor位置都是写上0.
                detector_mask[y_coord, x_coord, best_anchor] = 1
                # 这里注意一下张量的组织方式是：[b,h,w,5,x-y-w-h-l]
                matching_gt_box[y_coord, x_coord, best_anchor] = np.array([x, y, w, h, box[4]])

        # 以上完成的内容就是如下：
        # 完成[40,5]的张量变为 => 张量[16,16,5,5] 最后1个5位位置和类别。
        # matching_gt_box shape : [16,16,5,5]
        # detector_mask shape   : [16,16,5,1]
        # gt_boxes_grid shape   : [40,5]    坐标类型转换，左上角，右下角变为中心点，高宽。
        return matching_gt_box, detector_mask, gt_boxes_grid



3.2. 批量GT box合并以及批量Generator


# %%
# 2.2 回顾一下db对象是做过数据增强的generator，这个函数也是产生generator，可以给你给tensorflow用来做训练用。
def ground_truth_generator(db):

    for imgs, imgs_boxes in db:
        # imgs: [b,512,512,3]
        # imgs_boxes: [b,40,5]

        batch_matching_gt_box = []
        batch_detector_mask = []
        batch_gt_boxes_grid = []

        # print(imgs_boxes[0,:5])

        b = imgs.shape[0]  # 图片的数量，一个batchsz大小的。
        for i in range(b): # for each image
            ################# 调用上面写好的函数，转换格式。
            matching_gt_box, detector_mask, gt_boxes_grid = process_true_boxes(imgs_boxes[i], ANCHORS)
            batch_matching_gt_box.append(matching_gt_box)
            batch_detector_mask.append(detector_mask)
            batch_gt_boxes_grid.append(gt_boxes_grid)
        ###### [b,16,16,5,1]表示：b张图片，每张图片16*16的网格，每个网格有5个anchor box，每个anchor box的0或者1表示是否有GT box存在。
        detector_mask = tf.cast(np.array(batch_detector_mask), dtype=tf.float32)
        # [b,16,16,5,5] x-y-w-h-l
        matching_gt_box = tf.cast(np.array(batch_matching_gt_box), dtype=tf.float32)
        # [b,40,5] x-y-w-h-l
        gt_boxes_grid = tf.cast(np.array(batch_gt_boxes_grid), dtype=tf.float32)

        ###### [b,16,16,5] 因为需要用来分类，需要提取额外的类别信息。
        matching_classes = tf.cast(matching_gt_box[...,4], dtype=tf.int32)
        ###### [b,16,16,5,3] 做一个one_hot编码
        matching_classes_oh = tf.one_hot(matching_classes, depth=3)
        ######注意==== 网络输出7位格式：x-y-w-h-conf-l1-l2，depth=3这里由于：label1和label2并不是互斥的，有可能都为0，
        ###### 因此在做one_hot编码的时候，需要编码为3类，但是只取后2类，这样有可能l1，l2都有可能为0的。
        ###### [b,16,16,5,2]
        matching_classes_oh = tf.cast(matching_classes_oh[...,1:], dtype=tf.float32) # 这里只取后2位。


        # imgs：                 [b,512,512,3]
        # detector_mask：        [b,16,16,5,1]
        # matching_gt_box：      [b,16,16,5,5]
        # matching_classes_oh：  [b,16,16,5,2]
        # gt_boxes_grid：        [b,40,5]
        yield imgs, detector_mask, matching_gt_box, matching_classes_oh,gt_boxes_grid




3.3. GT box可视化




这里我们可视化一下detector_mask，看看有没有object。看看当前网格有没有object。




# %%
# 2.3 visualize object mask
# train_db -> aug_train_db -> train_gen
train_gen = ground_truth_generator(aug_train_db)

img, detector_mask, matching_gt_box, matching_classes_oh,gt_boxes_grid = \
    next(train_gen) # 带batchsz
img, detector_mask, matching_gt_box, matching_classes_oh, gt_boxes_grid = \
    img[0], detector_mask[0], matching_gt_box[0], matching_classes_oh[0], gt_boxes_grid[0] # 不带batch

fig,(ax1,ax2) = plt.subplots(2,figsize=(5,10))
ax1.imshow(img)
# [16,16,5,1] => [16,16,1]
mask = tf.reduce_sum(detector_mask, axis=2)
ax2.matshow(mask[...,0]) # [16,16]
plt.show()




〖TensorFlow2.0笔记26〗YOLOV2目标检测算法以及实战！_第13张图片



四. YOLOV2算法实战之Model


4.1. Darknet-19网络结构




Darknet-19网络结构





〖TensorFlow2.0笔记26〗YOLOV2目标检测算法以及实战！_第14张图片





这里首先测试一下输出




# 3.1
from tensorflow.keras import layers
import  tensorflow.keras.backend as K

input_image = layers.Input((512,512, 3), dtype='float32')  # 创建一个输入层
# unit1
x = layers.Conv2D(32, (3,3), strides=(1,1), padding='same', name='conv_1', use_bias=False)(input_image) # 这里就是要介绍的方法，我们先创建一个类，然后再加括号表示通过这个类。
x = layers.BatchNormalization(name='norm_1')(x)
x = layers.LeakyReLU(alpha=0.1)(x)

x = layers.MaxPooling2D(pool_size=(2,2))(x)

output = x
# create model
model = keras.Model(input_image, output)
x = tf.random.normal((4, 512, 512, 3))
out = model(x)
print('out: ', out.shape)





输出shape信息：




out:  (4, 256, 256, 32)

Process finished with exit code 0





网络输出测试：




from tensorflow.keras import layers

import  tensorflow.keras.backend as K

# 这层先不管呢。
class SpaceToDepth(layers.Layer):

    def __init__(self, block_size, **kwargs):
        self.block_size = block_size
        super(SpaceToDepth, self).__init__(**kwargs)

    def call(self, inputs):
        x = inputs
        batch, height, width, depth = K.int_shape(x)
        batch = -1
        reduced_height = height // self.block_size
        reduced_width = width // self.block_size
        y = K.reshape(x, (batch, reduced_height, self.block_size,
                             reduced_width, self.block_size, depth))
        z = K.permute_dimensions(y, (0, 1, 3, 2, 4, 5))
        t = K.reshape(z, (batch, reduced_height, reduced_width, depth * self.block_size **2))
        return t

    def compute_output_shape(self, input_shape):
        shape =  (input_shape[0], input_shape[1] // self.block_size, input_shape[2] // self.block_size,
                  input_shape[3] * self.block_size **2)
        return tf.TensorShape(shape)

IMGSZ=512
# 3.1
input_image = layers.Input((IMGSZ,IMGSZ, 3), dtype='float32')  # 创建一个输入层
# unit1
x = layers.Conv2D(32, (3,3), strides=(1,1), padding='same', name='conv_1', use_bias=False)(input_image) # 这里就是要介绍的方法，我们先创建一个类，然后再加括号表示通过这个类。
x = layers.BatchNormalization(name='norm_1')(x)
x = layers.LeakyReLU(alpha=0.1)(x)

x = layers.MaxPooling2D(pool_size=(2,2))(x)

# unit2
x = layers.Conv2D(64, (3,3), strides=(1,1), padding='same', name='conv_2',use_bias=False)(x)
x = layers.BatchNormalization(name='norm_2')(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.MaxPooling2D(pool_size=(2,2))(x)

# Layer 3
x = layers.Conv2D(128, (3,3), strides=(1,1), padding='same', name='conv_3', use_bias=False)(x)
x = layers.BatchNormalization(name='norm_3')(x)
x = layers.LeakyReLU(alpha=0.1)(x)

# Layer 4
x = layers.Conv2D(64, (1,1), strides=(1,1), padding='same', name='conv_4', use_bias=False)(x)
x = layers.BatchNormalization(name='norm_4')(x)
x = layers.LeakyReLU(alpha=0.1)(x)


# Layer 5
x = layers.Conv2D(128, (3,3), strides=(1,1), padding='same', name='conv_5', use_bias=False)(x)
x = layers.BatchNormalization(name='norm_5')(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.MaxPooling2D(pool_size=(2, 2))(x)

# Layer 6
x = layers.Conv2D(256, (3,3), strides=(1,1), padding='same', name='conv_6', use_bias=False)(x)
x = layers.BatchNormalization(name='norm_6')(x)
x = layers.LeakyReLU(alpha=0.1)(x)

# Layer 7
x = layers.Conv2D(128, (1,1), strides=(1,1), padding='same', name='conv_7', use_bias=False)(x)
x = layers.BatchNormalization(name='norm_7')(x)
x = layers.LeakyReLU(alpha=0.1)(x)

# Layer 8
x = layers.Conv2D(256, (3,3), strides=(1,1), padding='same', name='conv_8', use_bias=False)(x)
x = layers.BatchNormalization(name='norm_8')(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.MaxPooling2D(pool_size=(2, 2))(x)

# Layer 9
x = layers.Conv2D(512, (3,3), strides=(1,1), padding='same', name='conv_9', use_bias=False)(x)
x = layers.BatchNormalization(name='norm_9')(x)
x = layers.LeakyReLU(alpha=0.1)(x)

# Layer 10
x = layers.Conv2D(256, (1,1), strides=(1,1), padding='same', name='conv_10', use_bias=False)(x)
x = layers.BatchNormalization(name='norm_10')(x)
x = layers.LeakyReLU(alpha=0.1)(x)

# Layer 11
x = layers.Conv2D(512, (3,3), strides=(1,1), padding='same', name='conv_11', use_bias=False)(x)
x = layers.BatchNormalization(name='norm_11')(x)
x = layers.LeakyReLU(alpha=0.1)(x)

# Layer 12
x = layers.Conv2D(256, (1,1), strides=(1,1), padding='same', name='conv_12', use_bias=False)(x)
x = layers.BatchNormalization(name='norm_12')(x)
x = layers.LeakyReLU(alpha=0.1)(x)

# Layer 13
x = layers.Conv2D(512, (3,3), strides=(1,1), padding='same', name='conv_13', use_bias=False)(x)
x = layers.BatchNormalization(name='norm_13')(x)
x = layers.LeakyReLU(alpha=0.1)(x)

###################################### for skip connection 这里的短接线 ######################################
skip_x = x   #shape: [b,32,32,512]
###################################### for skip connection 这里的短接线 ######################################


x = layers.MaxPooling2D(pool_size=(2, 2))(x)

# Layer 14
x = layers.Conv2D(1024, (3, 3), strides=(1, 1), padding='same', name='conv_14', use_bias=False)(x)
x = layers.BatchNormalization(name='norm_14')(x)
x = layers.LeakyReLU(alpha=0.1)(x)

# Layer 15
x = layers.Conv2D(512, (1, 1), strides=(1, 1), padding='same', name='conv_15', use_bias=False)(x)
x = layers.BatchNormalization(name='norm_15')(x)
x = layers.LeakyReLU(alpha=0.1)(x)

# Layer 16
x = layers.Conv2D(1024, (3, 3), strides=(1, 1), padding='same', name='conv_16', use_bias=False)(x)
x = layers.BatchNormalization(name='norm_16')(x)
x = layers.LeakyReLU(alpha=0.1)(x)

# Layer 17
x = layers.Conv2D(512, (1, 1), strides=(1, 1), padding='same', name='conv_17', use_bias=False)(x)
x = layers.BatchNormalization(name='norm_17')(x)
x = layers.LeakyReLU(alpha=0.1)(x)

# Layer 18
x = layers.Conv2D(1024, (3, 3), strides=(1, 1), padding='same', name='conv_18', use_bias=False)(x)
x = layers.BatchNormalization(name='norm_18')(x)
x = layers.LeakyReLU(alpha=0.1)(x)

# Layer 19
x = layers.Conv2D(1024, (3, 3), strides=(1, 1), padding='same', name='conv_19', use_bias=False)(x)
x = layers.BatchNormalization(name='norm_19')(x)
x = layers.LeakyReLU(alpha=0.1)(x)

# Layer 20
x = layers.Conv2D(1024, (3, 3), strides=(1, 1), padding='same', name='conv_20', use_bias=False)(x)
x = layers.BatchNormalization(name='norm_20')(x)
x = layers.LeakyReLU(alpha=0.1)(x)
# shape x: (4, 16, 16, 1024)

# Layer 21
###################################### for skip connection 这里的短接线 ######################################
skip_x = layers.Conv2D(64, (1, 1), strides=(1, 1), padding='same', name='conv_21', use_bias=False)(skip_x)
skip_x = layers.BatchNormalization(name='norm_21')(skip_x)
skip_x = layers.LeakyReLU(alpha=0.1)(skip_x)
###################################### for skip connection 这里的短接线 ######################################
skip_x = SpaceToDepth(block_size=2)(skip_x)

# concat拼接操作
# [b,16,16,1024], [b,16,16,256],=> [b,16,16,1280]
x = tf.concat([skip_x, x], axis=-1)

# Layer 22
x = layers.Conv2D(1024, (3, 3), strides=(1, 1), padding='same', name='conv_22', use_bias=False)(x)
x = layers.BatchNormalization(name='norm_22')(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.Dropout(0.5)(x)  # add dropout
# 最终我们要得到的输出是：[b,16,16,5,7] => [b,16,16,35]

x = layers.Conv2D(5 * 7, (1, 1), strides=(1, 1), padding='same', name='conv_23')(x) #得到的shape：[b,16,16,35]

output = layers.Reshape((GRIDSZ, GRIDSZ, 5, 7))(x)          ####### reshape操作


# create model
model = keras.models.Model(input_image, output)
x = tf.random.normal((4, 512, 512, 3))
out = model(x)
print('out:', out.shape)





输出shape信息：




out: (4, 16, 16, 5, 7)



4.2. 网络初始化


# %%
# 3.2 权重初始化
class WeightReader:
    def __init__(self, weight_file):
        self.offset = 4
        self.all_weights = np.fromfile(weight_file, dtype='float32')

    def read_bytes(self, size):
        self.offset = self.offset + size
        return self.all_weights[self.offset - size:self.offset]

    def reset(self):
        self.offset = 4
weight_reader = WeightReader('yolo.weights')


weight_reader.reset()
nb_conv = 23

for i in range(1, nb_conv + 1):
    conv_layer = model.get_layer('conv_' + str(i))
    conv_layer.trainable = True

    if i < nb_conv:
        norm_layer = model.get_layer('norm_' + str(i))
        norm_layer.trainable = True

        size = np.prod(norm_layer.get_weights()[0].shape)

        beta = weight_reader.read_bytes(size)
        gamma = weight_reader.read_bytes(size)
        mean = weight_reader.read_bytes(size)
        var = weight_reader.read_bytes(size)

        weights = norm_layer.set_weights([gamma, beta, mean, var])

    if len(conv_layer.get_weights()) > 1:
        bias = weight_reader.read_bytes(np.prod(conv_layer.get_weights()[1].shape))
        kernel = weight_reader.read_bytes(np.prod(conv_layer.get_weights()[0].shape))
        kernel = kernel.reshape(list(reversed(conv_layer.get_weights()[0].shape)))
        kernel = kernel.transpose([2, 3, 1, 0])
        conv_layer.set_weights([kernel, bias])
    else:
        kernel = weight_reader.read_bytes(np.prod(conv_layer.get_weights()[0].shape))
        kernel = kernel.reshape(list(reversed(conv_layer.get_weights()[0].shape)))
        kernel = kernel.transpose([2, 3, 1, 0])
        conv_layer.set_weights([kernel])


layer = model.layers[-2]  # last convolutional layer
# print(layer.name) # conv_23
layer.trainable = True

weights = layer.get_weights()

new_kernel = np.random.normal(size=weights[0].shape) / (GRIDSZ * GRIDSZ)
new_bias = np.random.normal(size=weights[1].shape) / (GRIDSZ * GRIDSZ)

layer.set_weights([new_kernel, new_bias])



4.3. 网络输出可视化


#%%

model.load_weights('C:\\zhang\\codes\\yolov2-tf2\\weights\\ckpt.h5')

#%%
img, detector_mask, matching_gt_boxes, matching_classes_oh, gt_boxes_grid = next(train_gen)

img, detector_mask, matching_gt_boxes, matching_classes_oh, gt_boxes_grid = \
    img[0], detector_mask[0], matching_gt_boxes[0], matching_classes_oh[0], gt_boxes_grid[0]

# [b,512,512,3]=>[b,16,16,5,7]=>[16,16,5,x-y-w-h-conf-l1-l2]
y_pred = model(tf.expand_dims(img, axis=0))[0][...,4]
# [16,16,5] => [16,16]
y_pred = tf.reduce_sum(y_pred,axis=2)

fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2)
ax1.imshow(img)
# [16,16,5,1]=>[16,16]
ax2.matshow(tf.reduce_sum(detector_mask,axis=2)[...,0])
ax3.matshow(y_pred)




〖TensorFlow2.0笔记26〗YOLOV2目标检测算法以及实战！_第15张图片



五. YOLOV2算法实战之Loss




输出shape信息：





〖TensorFlow2.0笔记26〗YOLOV2目标检测算法以及实战！_第16张图片



# %%
from tensorflow.keras import losses

def compute_iou(x1,y1,w1,h1, x2,y2,w2,h2):
    # x1...:[b,16,16,5]
    xmin1 = x1 - 0.5*w1
    xmax1 = x1 + 0.5*w1
    ymin1 = y1 - 0.5*h1 
    ymax1 = y1 + 0.5*h1 

    xmin2 = x2 - 0.5*w2
    xmax2 = x2 + 0.5*w2
    ymin2 = y2 - 0.5*h2
    ymax2 = y2 + 0.5*h2

    # (xmin1,ymin1,xmax1,ymax1) (xmin2,ymin2,xmax2,ymax2)
    interw = np.minimum(xmax1,xmax2) - np.maximum(xmin1,xmin2)
    interh = np.minimum(ymax1, ymax2) - np.maximum(ymin1, ymin2)
    inter = interw * interh
    union = w1*h1 +w2*h2 - inter 
    iou = inter / (union + 1e-6)
    # [b,16,16,5]
    return iou 

#%%
# 4.1 coordinate loss
def yolo_loss(detector_mask, matching_gt_boxes, matching_classes_oh, gt_boxes_grid, y_pred):
    # detector_mask:        [b,16,16,5,1]
    # matching_gt_boxes:    [b,16,16,5,5] x-y-w-h-l
    # matching_classes_oh:  [b,16,16,5,2] l1-l2
    # gt_boxes_grid:        [b,40,5] x-y-w-h-l
    # y_pred:               [b,16,16,5,7] x-y-w-h-conf-l0-l1

    anchors = np.array(ANCHORS).reshape(5,2)

    # create starting position for each grid anchors
    # [16,16]
    x_grid = tf.tile(tf.range(GRIDSZ),[GRIDSZ])
    # [1,16,16,1,1]
    # [b,16,16,5,2]
    x_grid = tf.reshape(x_grid, (1,GRIDSZ,GRIDSZ,1,1))
    x_grid = tf.cast(x_grid, tf.float32)
    # [b,16_1,16_2,1,1]=>[b,16_2,16_1,1,1]
    y_grid = tf.transpose(x_grid, (0,2,1,3,4))
    xy_grid = tf.concat([x_grid, y_grid],axis=-1)
    # [1,16,16,1,2]=> [b,16,16,5,2]
    xy_grid = tf.tile(xy_grid, [y_pred.shape[0], 1,1,5,1])

    # [b,16,16,5,7] x-y-w-h-conf-l1-l2
    pred_xy = tf.sigmoid(y_pred[...,0:2])
    pred_xy = pred_xy + xy_grid
    # [b,16,16,5,2]
    pred_wh = tf.exp(y_pred[...,2:4])
    # [b,16,16,5,2] * [5,2] => [b,16,16,5,2]
    pred_wh = pred_wh * anchors

    # 统计box的数量，用来做平均。
    n_detector_mask = tf.reduce_sum(tf.cast(detector_mask>0., tf.float32))
    # [b,16,16,5,1] * [b,16,16,5,2]

    #
    xy_loss = detector_mask * tf.square(matching_gt_boxes[...,:2]-pred_xy) / (n_detector_mask+1e-6)
    xy_loss  = tf.reduce_sum(xy_loss)
    wh_loss = detector_mask * tf.square(tf.sqrt(matching_gt_boxes[...,2:4])-\
    	tf.sqrt(pred_wh)) / (n_detector_mask+1e-6)
    wh_loss  = tf.reduce_sum(wh_loss)

    ################ 4.1 coordinate loss
    coord_loss = xy_loss + wh_loss 

    ################ 4.2 class loss
    # [b,16,16,5,2]
    pred_box_class = y_pred[...,5:]
    # [b,16,16,5]
    true_box_class = tf.argmax(matching_classes_oh,-1)  ############### one_hot逆密码，转过来
    # [b,16,16,5] vs [b,16,16,5,2]
    class_loss = losses.sparse_categorical_crossentropy(true_box_class, pred_box_class, from_logits=True)
    # [b,16,16,5] => [b,16,16,5,1]* [b,16,16,5,1]
    class_loss = tf.expand_dims(class_loss,-1) * detector_mask      # 插入维度。
    class_loss = tf.reduce_sum(class_loss) / (n_detector_mask+1e-6) # n_detector_mask 有目标的数量。
 
    ################ 4.3 object loss  这个loss更加复杂
    # nonobject_mask
    # iou done!
    # [b,16,16,5]
    x1,y1,w1,h1 = matching_gt_boxes[...,0],matching_gt_boxes[...,1],matching_gt_boxes[...,2],matching_gt_boxes[...,3]
    # [b,16,16,5]
    x2,y2,w2,h2 = pred_xy[...,0],pred_xy[...,1],pred_wh[...,0],pred_wh[...,1]
    ious = compute_iou(x1,y1,w1,h1, x2,y2,w2,h2)
    # [b,16,16,5,1]
    ious = tf.expand_dims(ious, axis=-1)

    # [b,16,16,5,1]
    pred_conf = tf.sigmoid(y_pred[...,4:5])
    # [b,16,16,5,2] => [b,16,16,5, 1, 2]
    pred_xy = tf.expand_dims(pred_xy, axis=4)
    # [b,16,16,5,2] => [b,16,16,5, 1, 2]
    pred_wh = tf.expand_dims(pred_wh, axis=4)
    pred_wh_half = pred_wh /2. 
    pred_xymin = pred_xy - pred_wh_half
    pred_xymax = pred_xy + pred_wh_half

    # [b, 40, 5] => [b, 1, 1, 1, 40, 5]
    true_boxes_grid = tf.reshape(gt_boxes_grid, \
        [gt_boxes_grid.shape[0], 1, 1 ,1, gt_boxes_grid.shape[1], gt_boxes_grid.shape[2]])
    true_xy = true_boxes_grid[...,0:2]
    true_wh = true_boxes_grid[...,2:4]
    true_wh_half = true_wh /2. 
    true_xymin = true_xy - true_wh_half
    true_xymax = true_xy + true_wh_half
    # predxymin, predxymax, true_xymin, true_xymax
    # [b,16,16,5,1,2] vs [b,1,1,1,40,2]=> [b,16,16,5,40,2]
    intersectxymin = tf.maximum(pred_xymin, true_xymin)
    # [b,16,16,5,1,2] vs [b,1,1,1,40,2]=> [b,16,16,5,40,2]
    intersectxymax = tf.minimum(pred_xymax, true_xymax)
    # [b,16,16,5,40,2]
    intersect_wh = tf.maximum(intersectxymax - intersectxymin, 0.)
    # [b,16,16,5,40] * [b,16,16,5,40]=>[b,16,16,5,40]
    intersect_area = intersect_wh[...,0] * intersect_wh[...,1]
    # [b,16,16,5,1]
    pred_area = pred_wh[...,0] * pred_wh[...,1]
    # [b,1,1,1,40]
    true_area = true_wh[...,0] * true_wh[...,1]
    # [b,16,16,5,1]+[b,1,1,1,40]-[b,16,16,5,40]=>[b,16,16,5,40]
    union_area = pred_area + true_area - intersect_area
    # [b,16,16,5,40]
    iou_score = intersect_area / union_area
    # [b,16,16,5]
    best_iou = tf.reduce_max(iou_score, axis=4)
    # [b,16,16,5,1]
    best_iou = tf.expand_dims(best_iou, axis=-1)

    nonobj_detection = tf.cast(best_iou<0.6, tf.float32)
    nonobj_mask = nonobj_detection * (1-detector_mask)
    # nonobj counter
    n_nonobj = tf.reduce_sum(tf.cast(nonobj_mask>0.,tf.float32))

    nonobj_loss = tf.reduce_sum(nonobj_mask * tf.square(-pred_conf))\
        /(n_nonobj+1e-6)
    obj_loss = tf.reduce_sum(detector_mask * tf.square(ious - pred_conf))\
         / (n_detector_mask+1e-6)

    loss = coord_loss + class_loss + nonobj_loss + 5 * obj_loss

    return loss, [nonobj_loss + 5 * obj_loss, class_loss, coord_loss]

#%%
img, detector_mask, matching_gt_boxes, matching_classes_oh, gt_boxes_grid = next(train_gen)

img, detector_mask, matching_gt_boxes, matching_classes_oh, gt_boxes_grid = \
    img[0], detector_mask[0], matching_gt_boxes[0], matching_classes_oh[0], gt_boxes_grid[0]

y_pred = model(tf.expand_dims(img, axis=0))[0]

loss, sub_loss =  yolo_loss(tf.expand_dims(detector_mask,axis=0), 
tf.expand_dims(matching_gt_boxes,axis=0), 
tf.expand_dims(matching_classes_oh,axis=0), 
tf.expand_dims(gt_boxes_grid,axis=0), 
tf.expand_dims(y_pred,axis=0)
)


























你可能感兴趣的:(〖TensorFlow2.0笔记26〗YOLOV2目标检测算法以及实战！)






    

  • 10月|愿你的青春不负梦想-读书笔记-01
Tracy的小书斋

    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
    

    • 

  • C语言如何定义宏函数？
小九格物
c语言

    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
    

    • 

  • 《投行人生》读书笔记
小蘑菇的树洞

    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
    

    • 

  • 2021-08-26
影幽

    在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
    

    • 

  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数
广龙宇
一起学Rust#Rust设计模式rust设计模式开发语言

    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
    

    • 

  • 本周第二次约练
2cfbdfe28a51

    中原焦点团队中24初26刘霞2021.12.3约练161次，分享第368天当事人虽然是带着问题来的，但是咨询过程中发现，她是经过自己不断地调整和努力才走到现在的，看到当事人的不容易，找到例外，发现资源，力量感也就随之而来。增强画面感，或者说重温，会给当事人带来更深刻的感受。
    

    • 

  • Python数据分析与可视化实战指南
William数据分析
pythonpython数据

    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
    

    • 

  • git常用命令笔记
咩酱-小羊
git笔记

    ###用习惯了idea总是不记得git的一些常见命令，需要用到的时候总是担心旁边站了人~~~记个笔记@_@，告诉自己看笔记不丢人初始化初始化一个新的Git仓库gitinit配置配置用户信息gitconfig--globaluser.name"YourName"gitconfig--globaluser.email"[email protected]"基本操作克隆远程仓库gitclone查看
    

    • 

  • Pyecharts数据可视化大屏：打造沉浸式数据分析体验
我的运维人生
信息可视化数据分析数据挖掘运维开发技术共享

    Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
    

    • 

  • 怎么起诉借钱不还的人？怎样起诉欠款不还的人？
影子爱学习

    怎么起诉借钱不还的人？怎样起诉欠款不还的人？如果遇到难以解决的法律问题，我们可以匹配专业律师。例如：婚姻家庭（离婚纠纷）、刑事辩护、合同纠纷、债权债务、房产（继承）纠纷、交通事故、劳动争议、人身损害、公司相关法律事务（法律顾问）等咨询推荐手机/微信:15633770876【全国案件皆可】借钱不还起诉对方需要哪些资料起诉欠钱不还的，一般需要的材料包括以下这些：借据、收据、欠条、付款凭证等证据，以及向
    

    • 

  • Python教程：一文了解使用Python处理XPath
旦莫
Python进阶python开发语言

    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
    

    • 

  • PHP环境搭建详细教程
好看资源平台
前端php

    PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
    

    • 

  • 509. 斐波那契数(每日一题)
lzyprime

    lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
    

    • 

  • 18-115 一切思考不能有效转化为行动，都TM是扯淡！
成长时间线

    7月25号写了一篇关于为什么会断更如此严重的反思，然而，之后日更仅仅维持了一周，又出现了这次更严重的现象。从8月2号到昨天8月6号，5天！又是5天没有更文！虽然这次断更时间和上次一样，那为什么说这次更严重？因为上次之后就分析了问题的原因，以及应该如何解决，按理说应该会好转，然而，没过几天严重断更的现象再次出现，想想，经过反思，问题依然没有解决与改变，这让我有些担忧。到底是哪里出了问题，难道我就真的
    

    • 

  • 拥有断舍离的心态，过精简生活--《断舍离》读书笔记
爱吃丸子的小樱桃

    不知不觉间房间里的东西越来越多，虽然摆放整齐，但也时常会觉得空间逼仄，令人心生烦闷。抱着断舍离的态度，我开始阅读《断舍离》这本书，希望从书中能找到一些有效的方法，帮助我实现空间、物品上的断舍离。《断舍离》是日本作家山下英子通过自己的经历、思考和实践总结而成的，整体内涵也从刚开始的私人生活哲学的“断舍离”升华成了“人生实践哲学”，接着又成为每个人都能实行的“改变人生的断舍离”，从“哲学”逐渐升华成“
    

    • 

  • 直返最高等级与直返APP：无需邀请码的返利新体验
古楼

    随着互联网的普及和电商的兴起，直返模式逐渐成为一种流行的商业模式。在这种模式下，消费者通过购买产品或服务，获得一定的返利，并可以分享给更多的人。其中，直返最高等级和直返APP是直返模式中的重要概念和工具。本文将详细介绍直返最高等级的概念、直返APP的使用以及与邀请码的关系。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，
    

    • 

  • 四章-32-点要素的聚合
彩云飘过

    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
    

    • 

  • 高端密码学院笔记285
柚子_b4b4

    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
    

    • 

  • 【加密社】Solidity 中的事件机制及其应用
加密社
闲侃区块链智能合约区块链

    加密社引言在Solidity合约开发过程中，事件（Events）是一种非常重要的机制。它们不仅能够让开发者记录智能合约的重要状态变更，还能够让外部系统（如前端应用）监听这些状态的变化。本文将详细介绍Solidity中的事件机制以及如何利用不同的手段来触发、监听和获取这些事件。事件存储的地方当我们在Solidity合约中使用emit关键字触发事件时，该事件会被记录在区块链的交易收据中。具体而言，事件
    

    • 

  • Day17笔记-高阶函数
~在杰难逃~
Python笔记python开发语言pycharm数据分析

    高阶函数【重点掌握】函数的本质：函数是一个变量，函数名是一个变量名，一个函数可以作为另一个函数的参数或返回值使用如果A函数作为B函数的参数，B函数调用完成之后，会得到一个结果，则B函数被称为高阶函数常用的高阶函数：map(),reduce(),filter(),sorted()1.map()map(func,iterable)，返回值是一个iterator【容器，迭代器】func:函数iterab
    

    • 

  • Day1笔记-Python简介&标识符和关键字&输入输出
~在杰难逃~
Pythonpython开发语言大数据数据分析数据挖掘

    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
    

    • 

  • 【目标检测数据集】卡车数据集1073张VOC+YOLO格式
熬夜写代码的平头哥∰
目标检测YOLO人工智能

    数据集格式：PascalVOC格式+YOLO格式(不包含分割路径的txt文件，仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件)图片数量(jpg文件个数)：1073标注数量(xml文件个数)：1073标注数量(txt文件个数)：1073标注类别数：1标注类别名称:["truck"]每个类别标注的框数：truck框数=1120总框数：1120使用标注工具：labelImg标注
    

    • 

  • 走向以教育叙事为载体的教育叙事研究
666小飞鱼

    今天我读了吴松超老师的《给教师的68条建写作建议》中的第23条《如何通过教育叙事走向研究》，吴老师在文中与我们分享了一个德育案例，这是一个反面的案例，意在告知我们在处理问题时，不能就考虑的点太窄，思考要全面。走向教育叙事研究，教师要有敏锐的“感知力”，这个感知力来自于背后专业知识的支撑，思维能力以及广阔的视野和见识等。所以对于同一件事处理方法不同，这个就是教师背后“敏锐力”的不同造成的，也就是说是
    

    • 

  • node.js学习
小猿L
node.jsnode.js学习vim

    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    

    • 

  • 钢筋长度超限检测检数据集VOC+YOLO格式215张1类别
futureflsl
数据集YOLO深度学习机器学习

    数据集格式：PascalVOC格式+YOLO格式(不包含分割路径的txt文件，仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件)图片数量(jpg文件个数)：215标注数量(xml文件个数)：215标注数量(txt文件个数)：215标注类别数：1标注类别名称:["iron"]每个类别标注的框数：iron框数=215总框数：215使用标注工具：labelImg标注规则：对类别进
    

    • 

  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（4)
算法大师
华为od面试python

    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
    

    • 

  • 【华为OD技术面试真题 - 技术面】-测试八股文真题题库（1）
算法大师
华为od面试python算法前端

    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.黑盒测试和白盒测试的区别2.假设我们公司现在开发一个类似于微信的软件1.0版本，现在要你测试这个功能：打开聊天窗口，输入文本，限制字数在200字以内。问你怎么提取测试点。功能测试性能测试安全性测试可用性测试跨平台兼容性测试网络环境测试3.接口测试的工具你了解哪些
    

    • 

  • 数据仓库——维度表一致性
墨染丶eye
背诵数据仓库

    数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
    

    • 

  • Low Power概念介绍-Voltage Area
飞奔的大虎

    随着智能手机，以及物联网的普及，芯片功耗的问题最近几年得到了越来越多的重视。为了实现集成电路的低功耗设计目标，我们需要在系统设计阶段就采用低功耗设计的方案。而且，随着设计流程的逐步推进，到了芯片后端设计阶段，降低芯片功耗的方法已经很少了，节省的功耗百分比也不断下降。芯片的功耗主要由静态功耗（staticleakagepower）和动态功耗(dynamicpower)构成。静态功耗主要是指电路处于等
    

    • 

  • Rust基础知识
GRKF15
rust开发语言后端

    1.Rust语言简介1.1基础语法变量声明：let关键字用于声明变量，可以指定或不指定类型，如leta=10;和letmutc=30i32;。函数定义：使用fn关键字定义函数，并指定参数类型及返回类型，如fnadd(i:i32,j:i32)->i32{i+j}。控制流：包括if、else等，控制语句后需要使用;来结束语句。1.2数据类型整数类型：i8、i16、i32、i64、i128，以及无符号的
    

    • 

  • apache 安装linux windows
墙头上一根草
apacheinuxwindows

    linux安装Apache 有两种方式一种是手动安装通过二进制的文件进行安装，另外一种就是通过yum 安装，此中安装方式，需要物理机联网。以下分别介绍两种的安装方式
 
 
通过二进制文件安装Apache需要的软件有apr,apr-util,pcre
 1，安装 apr        下载地址：htt
    

    • 

  • fill_parent、wrap_content和match_parent的区别
Cb123456
match_parentfill_parent

    fill_parent、wrap_content和match_parent的区别:
 
1）fill_parent
  设置一个构件的布局为fill_parent将强制性地使构件扩展，以填充布局单元内尽可能多的空间。这跟Windows控件的dockstyle属性大体一致。设置一个顶部布局或控件为fill_parent将强制性让它布满整个屏幕。
2） wrap_conte
    

    • 

  • 网页自适应设计
天子之骄
htmlcss响应式设计页面自适应

    网页自适应设计
       网页对浏览器窗口的自适应支持变得越来越重要了。自适应响应设计更是异常火爆。再加上移动端的崛起，更是如日中天。以前为了适应不同屏幕分布率和浏览器窗口的扩大和缩小，需要设计几套css样式，用js脚本判断窗口大小，选择加载。结构臃肿，加载负担较大。现笔者经过一定时间的学习，有所心得，故分享于此，加强交流，共同进步。同时希望对大家有所
    

    • 

  • [sql server] 分组取最大最小常用sql
一炮送你回车库
SQL Server

    --分组取最大最小常用sql--测试环境if OBJECT_ID('tb') is not null drop table tb;gocreate table tb( col1 int, col2 int, Fcount int)insert into tbselect 11,20,1 union allselect 11,22,1 union allselect 1
    

    • 

  • ImageIO写图片输出到硬盘
3213213333332132
javaimage

    package awt;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imagei
    

    • 

  • 自己的String动态数组
宝剑锋梅花香
java动态数组数组

    数组还是好说，学过一两门编程语言的就知道，需要注意的是数组声明时需要把大小给它定下来，比如声明一个字符串类型的数组：String str[]=new String[10];    但是问题就来了，每次都是大小确定的数组，我需要数组大小不固定随时变化怎么办呢？  动态数组就这样应运而生，龙哥给我们讲的是自己用代码写动态数组，并非用的ArrayList 看看字符
    

    • 

  • pinyin4j工具类
darkranger
.net

    pinyin4j工具类Java工具类 2010-04-24 00:47:00 阅读69 评论0 字号：大中小
引入pinyin4j-2.5.0.jar包:
pinyin4j是一个功能强悍的汉语拼音工具包，主要是从汉语获取各种格式和需求的拼音，功能强悍，下面看看如何使用pinyin4j。
本人以前用AscII编码提取工具，效果不理想，现在用pinyin4j简单实现了一个。功能还不是很完美，
    

    • 

  • StarUML学习笔记----基本概念
aijuans
UML建模

    介绍StarUML的基本概念，这些都是有效运用StarUML?所需要的。包括对模型、视图、图、项目、单元、方法、框架、模型块及其差异以及UML轮廓。
        模型、视与图（Model, View and Diagram）
       &
    

    • 

  • Activiti最终总结
avords
Activiti id 工作流

    1、流程定义ID：ProcessDefinitionId，当定义一个流程就会产生。
2、流程实例ID：ProcessInstanceId，当开始一个具体的流程时就会产生，也就是不同的流程实例ID可能有相同的流程定义ID。
3、TaskId，每一个userTask都会有一个Id这个是存在于流程实例上的。
4、TaskDefinitionKey和（ActivityImpl activityId 
    

    • 

  • 从省市区多重级联想到的，react和jquery的差别
bee1314
jqueryUIreact

    在我们的前端项目里经常会用到级联的select，比如省市区这样。通常这种级联大多是动态的。比如先加载了省，点击省加载市，点击市加载区。然后数据通常ajax返回。如果没有数据则说明到了叶子节点。   针对这种场景，如果我们使用jquery来实现，要考虑很多的问题，数据部分，以及大量的dom操作。比如这个页面上显示了某个区，这时候我切换省，要把市重新初始化数据，然后区域的部分要从页面
    

    • 

  • Eclipse快捷键大全
bijian1013
javaeclipse快捷键

    Ctrl+1 快速修复(最经典的快捷键,就不用多说了)Ctrl+D: 删除当前行 Ctrl+Alt+↓ 复制当前行到下一行(复制增加)Ctrl+Alt+↑ 复制当前行到上一行(复制增加)Alt+↓ 当前行和下面一行交互位置(特别实用,可以省去先剪切,再粘贴了)Alt+↑ 当前行和上面一行交互位置(同上)Alt+← 前一个编辑的页面Alt+→ 下一个编辑的页面(当然是针对上面那条来说了)Alt+En
    

    • 

  • js 笔记 函数
征客丶
JavaScript

    一、函数的使用
1.1、定义函数变量
var vName = funcation(params){
}
1.2、函数的调用
函数变量的调用：      vName(params);
函数定义时自发调用：(function(params){})(params);
1.3、函数中变量赋值
var a = 'a';
var ff
    

    • 

  • 【Scala四】分析Spark源代码总结的Scala语法二
bit1129
scala

    1. Some操作
 
在下面的代码中，使用了Some操作：if (self.partitioner == Some(partitioner))，那么Some(partitioner)表示什么含义？首先partitioner是方法combineByKey传入的变量，
Some的文档说明：
 
/** Class `Some[A]` represents existin
    

    • 

  • java 匿名内部类
BlueSkator
java匿名内部类

    组合优先于继承
Java的匿名类，就是提供了一个快捷方便的手段，令继承关系可以方便地变成组合关系
继承只有一个时候才能用，当你要求子类的实例可以替代父类实例的位置时才可以用继承。
 
在Java中内部类主要分为成员内部类、局部内部类、匿名内部类、静态内部类。
内部类不是很好理解，但说白了其实也就是一个类中还包含着另外一个类如同一个人是由大脑、肢体、器官等身体结果组成，而内部类相
    

    • 

  • 盗版win装在MAC有害发热，苹果的东西不值得买，win应该不用
ljy325
游戏applewindowsXPOS

    Mac mini 型号: MC270CH-A RMB:5,688
 
Apple 对windows的产品支持不好,有以下问题:
 
1.装完了xp,发现机身很热虽然没有运行任何程序！貌似显卡跑游戏发热一样，按照那样的发热量,那部机子损耗很大,使用寿命受到严重的影响!
 
2.反观安装了Mac os的展示机，发热量很小，运行了1天温度也没有那么高
&nbs
    

    • 

  • 读《研磨设计模式》-代码笔记-生成器模式-Builder
bylijinnan
java设计模式

    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/
/**
* 生成器模式的意图在于将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示（GoF）
* 个人理解：
* 构建一个复杂的对象，对于创建者（Builder）来说，一是要有数据来源(rawData)，二是要返回构
    

    • 

  • JIRA与SVN插件安装
chenyu19891124
SVNjira

    JIRA安装好后提交代码并要显示在JIRA上，这得需要用SVN的插件才能看见开发人员提交的代码。
1.下载svn与jira插件安装包，解压后在安装包(atlassian-jira-subversion-plugin-0.10.1)
2.解压出来的包里下的lib文件夹下的jar拷贝到(C:\Program Files\Atlassian\JIRA 4.3.4\atlassian-jira\WEB
    

    • 

  • 常用数学思想方法
comsci
工作

      对于搞工程和技术的朋友来讲，在工作中常常遇到一些实际问题，而采用常规的思维方式无法很好的解决这些问题，那么这个时候我们就需要用数学语言和数学工具，而使用数学工具的前提却是用数学思想的方法来描述问题。。下面转帖几种常用的数学思想方法，仅供学习和参考
  函数思想
　　把某一数学问题用函数表示出来，并且利用函数探究这个问题的一般规律。这是最基本、最常用的数学方法
    

    • 

  • pl/sql集合类型
daizj
oracle集合typepl/sql

    --集合类型
/*
  单行单列的数据，使用标量变量
  单行多列数据，使用记录
  单列多行数据，使用集合（。。。）
  *集合：类似于数组也就是。pl/sql集合类型包括索引表（pl/sql table）、嵌套表（Nested Table）、变长数组（VARRAY）等
*/
/*
    --集合方法
&n
    

    • 

  • [Ofbiz]ofbiz初用
dinguangx
电商ofbiz

    从github下载最新的ofbiz（截止2015-7-13），从源码进行ofbiz的试用
1. 加载测试库
ofbiz内置derby，通过下面的命令初始化测试库
./ant load-demo (与load-seed有一些区别)
 
2. 启动内置tomcat
./ant start
或
./startofbiz.sh
或
java -jar ofbiz.jar
&
    

    • 

  • 结构体中最后一个元素是长度为0的数组
dcj3sjt126com
cgcc

    在Linux源代码中，有很多的结构体最后都定义了一个元素个数为0个的数组，如/usr/include/linux/if_pppox.h中有这样一个结构体： struct pppoe_tag {     __u16 tag_type;     __u16 tag_len;   &n
    

    • 

  • Linux cp 实现强行覆盖
dcj3sjt126com
linux

    发现在Fedora 10 /ubutun 里面用cp -fr src dest，即使加了-f也是不能强行覆盖的，这时怎么回事的呢？一两个文件还好说，就输几个yes吧，但是要是n多文件怎么办，那还不输死人呢？下面提供三种解决办法。 方法一
我们输入alias命令，看看系统给cp起了一个什么别名。
[root@localhost ~]# aliasalias cp=’cp -i’a
    

    • 

  • Memcached(一)、HelloWorld
frank1234
memcached

    一、简介
高性能的架构离不开缓存，分布式缓存中的佼佼者当属memcached，它通过客户端将不同的key hash到不同的memcached服务器中，而获取的时候也到相同的服务器中获取，由于不需要做集群同步，也就省去了集群间同步的开销和延迟，所以它相对于ehcache等缓存来说能更好的支持分布式应用，具有更强的横向伸缩能力。
二、客户端
选择一个memcached客户端，我这里用的是memc
    

    • 

  • Search in Rotated Sorted Array II
hcx2013
search

    Follow up for "Search in Rotated Sorted Array":What if duplicates are allowed?
Would this affect the run-time complexity? How and why?
Write a function to determine if a given ta
    

    • 

  • Spring4新特性——更好的Java泛型操作API
jinnianshilongnian
spring4generic type

    Spring4新特性——泛型限定式依赖注入
Spring4新特性——核心容器的其他改进
Spring4新特性——Web开发的增强
Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC 
Spring4新特性——Groovy Bean定义DSL
Spring4新特性——更好的Java泛型操作API 
Spring4新
    

    • 

  • CentOS安装JDK
liuxingguome
centos

    1、行卸载原来的：
[root@localhost opt]# rpm -qa | grep java
tzdata-java-2014g-1.el6.noarch
java-1.7.0-openjdk-1.7.0.65-2.5.1.2.el6_5.x86_64
java-1.6.0-openjdk-1.6.0.0-11.1.13.4.el6.x86_64
[root@localhost
    

    • 

  • 二分搜索专题2-在有序二维数组中搜索一个元素
OpenMind
二维数组算法二分搜索

    1,设二维数组p的每行每列都按照下标递增的顺序递增。
用数学语言描述如下：p满足
(1),对任意的x1，x2，y，如果x1<x2,则p(x1,y)<p(x2,y);
(2),对任意的x，y1,y2, 如果y1<y2,则p(x,y1)<p(x,y2);
2,问题：
给定满足1的数组p和一个整数k，求是否存在x0,y0使得p(x0,y0)=k?
3,算法分析：
(
    

    • 

  • java 随机数 Math与Random
SaraWon
javaMathRandom

    今天需要在程序中产生随机数，知道有两种方法可以使用，但是使用Math和Random的区别还不是特别清楚，看到一篇文章是关于的，觉得写的还挺不错的，原文地址是
http://www.oschina.net/question/157182_45274?sort=default&p=1#answers
产生1到10之间的随机数的两种实现方式：
//Math
Math.roun
    

    • 

  • oracle创建表空间
tugn
oracle

    create temporary tablespace TXSJ_TEMP  
tempfile 'E:\Oracle\oradata\TXSJ_TEMP.dbf'  
size 32m  
autoextend on  
next 32m maxsize 2048m  
extent m
    

    • 

  • 使用Java8实现自己的个性化搜索引擎
yangshangchuan
javasuperword搜索引擎java8全文检索

    需要对249本软件著作实现句子级别全文检索，这些著作均为PDF文件，不使用现有的框架如lucene，自己实现的方法如下：
1、从PDF文件中提取文本，这里的重点是如何最大可能地还原文本。提取之后的文本，一个句子一行保存为文本文件。
2、将所有文本文件合并为一个单一的文本文件，这样，每一个句子就有一个唯一行号。
3、对每一行文本进行分词，建立倒排表，倒排表的格式为：词=包含该词的总行数N=行号
    

    •