YOLOv3源码解析2-数据预处理Dataset()
YOLOv3源码解析1-代码整体结构
YOLOv3源码解析2-数据预处理Dataset()
YOLOv3源码解析3-网络结构YOLOV3()
YOLOv3源码解析4-计算损失compute_loss()
YOLOv3源码解析5-损失函数
理论部分参照大神的文章学习：
简书：关于YOLOv3的一些细节
github：源代码作者YOLOV3
知乎：【YOLO】yolo v1到yolo v3
知乎：目标检测|YOLO原理与实现
知乎：YOLO v3深入理解
CSDN：yolo系列之yolo v3【深度解析】
解析的代码地址：
github:tensorflow-yolov3
本文解析Dataset()数据预处理部分：
该部分主要作用是：读取数据集信息，并将标注数据进行一系列的预处理，最终按batch_size大小返回：图像、大中小标记框的标签及坐标信息。下面这个图只能说个大概，细节都在代码里，话不多说，解析源码吧。
在代码的train.py的第34,35行调用了Dataset()
self.trainset = Dataset('train') # 数据集设置 ******************
self.testset = Dataset('test') # 数据集设置 ******************然后进入到dataset.py文件，进入Dataset()类，首先执行__init__函数，该函数中除了从配置文件中读取一些相关参数外，还执行了下面这行代码：
self.annotations = self.load_annotations(dataset_type) # 获取图像信息列表该代码调用load_annotations()函数，读取图像信息，其信息格式应该是这样的：
格式为前面是图像路径+空格+标记框信息（x1,y1,x2,y2,itype）
load_annotations()函数源代码：
# 获取图像信息列表
def load_annotations(self, dataset_type):
with open(self.annot_path, 'r') as f:
txt = f.readlines()
annotations = [line.strip() for line in txt if len(line.strip().split()[1:]) != 0]
np.random.shuffle(annotations) # 随机打乱
return annotations下面进入关键的__next__函数：
该函数最终返回的是：按batch_size大小返回图像、大中小标记框的标签及坐标信息。
def __next__(self):
with tf.device('/cpu:0'):
self.train_input_size = random.choice(self.train_input_sizes) # 随机选择一个训练图像的尺寸
self.train_output_sizes = self.train_input_size // self.strides # 图像尺寸除以缩放倍率，得到输出图像尺寸 【52,26,13】3个尺寸
batch_image = np.zeros((self.batch_size, self.train_input_size, self.train_input_size, 3)) # 输入图像 1*448*448*3
# 1*52*52*3*85
batch_label_sbbox = np.zeros((self.batch_size, self.train_output_sizes[0], self.train_output_sizes[0],
self.anchor_per_scale, 5 + self.num_classes))
batch_label_mbbox = np.zeros((self.batch_size, self.train_output_sizes[1], self.train_output_sizes[1],
self.anchor_per_scale, 5 + self.num_classes))
batch_label_lbbox = np.zeros((self.batch_size, self.train_output_sizes[2], self.train_output_sizes[2],
self.anchor_per_scale, 5 + self.num_classes))
# 1*150*4
batch_sbboxes = np.zeros((self.batch_size, self.max_bbox_per_scale, 4))
batch_mbboxes = np.zeros((self.batch_size, self.max_bbox_per_scale, 4))
batch_lbboxes = np.zeros((self.batch_size, self.max_bbox_per_scale, 4))
num = 0
if self.batch_count < self.num_batchs:
while num < self.batch_size:
index = self.batch_count * self.batch_size + num # 计算获取图像的索引
if index >= self.num_samples: index -= self.num_samples # 如果索引超出了图像数量，则减去图像数量，从头开始
annotation = self.annotations[index] # 从图像名称列表中获取图像名称
image, bboxes = self.parse_annotation(annotation) # 解析annotation，获取图像数据和标记框（做一些预处理）
# 对标记框做一些预处理
label_sbbox, label_mbbox, label_lbbox, sbboxes, mbboxes, lbboxes = self.preprocess_true_boxes(bboxes)
batch_image[num, :, :, :] = image
batch_label_sbbox[num, :, :, :, :] = label_sbbox
batch_label_mbbox[num, :, :, :, :] = label_mbbox
batch_label_lbbox[num, :, :, :, :] = label_lbbox
batch_sbboxes[num, :, :] = sbboxes
batch_mbboxes[num, :, :] = mbboxes
batch_lbboxes[num, :, :] = lbboxes
num += 1
self.batch_count += 1
return batch_image, batch_label_sbbox, batch_label_mbbox, batch_label_lbbox, \
batch_sbboxes, batch_mbboxes, batch_lbboxes
else:
self.batch_count = 0
np.random.shuffle(self.annotations)
raise StopIteration # 结束中间调用了 parse_annotation(annotation)函数，主要是 解析annotation，获取图像数据和标记框（做一些预处理）；以及调用了preprocess_true_boxes(bboxes)函数，主要是对标记框做一些预处理。
- parse_annotation(annotation)函数
主要是根据列表信息读取图像以及获取该图像标记框信息，并根据需要对图像做一些处理，如：随机水平翻转、随机裁剪图像、随机移动图像，这3个操作各有1个函数，代码我就不贴了。
'''
根据列表信息读取图像以及获取该图像标记框信息
annotation="./VOC2007/JPEGImages/000002.jpg 139,200,207,301,18"
'''
def parse_annotation(self, annotation):
line = annotation.split() # 分解当前图像路径
image_path = line[0] # 图像路径
if not os.path.exists(image_path): # 判断路径是否存在
raise KeyError("%s does not exist ... " %image_path)
image = np.array(cv2.imread(image_path)) # 读取图像
bboxes = np.array([list(map(int, box.split(','))) for box in line[1:]]) # 分解出标记框的信息
if self.data_aug:
image, bboxes = self.random_horizontal_flip(np.copy(image), np.copy(bboxes)) # 随机水平翻转
image, bboxes = self.random_crop(np.copy(image), np.copy(bboxes)) # 随机裁剪图像
image, bboxes = self.random_translate(np.copy(image), np.copy(bboxes)) #随机移动图像
# 将输入图像按训练选取的图像尺寸进行缩放，空白部分用灰度值128填充
image, bboxes = utils.image_preporcess(np.copy(image), [self.train_input_size, self.train_input_size], np.copy(bboxes))
return image, bboxes1.随机水平翻转
'''
随机水平翻转
'''
def random_horizontal_flip(self, image, bboxes):
if random.random() < 0.5: # 如果产生的随机数小于0.5
_, w, _ = image.shape
image = image[:, ::-1, :] # 翻转图像
bboxes[:, [0, 2]] = w - bboxes[:, [2, 0]] - 1 # 翻转标记框
return image, bboxes2.随机裁剪图像
'''
随机裁剪图像
'''
def random_crop(self, image, bboxes):
if random.random() < 0.5: # 如果随机生成的数小于0.5
h, w, _ = image.shape
max_bbox = np.concatenate([np.min(bboxes[:, 0:2], axis=0), np.max(bboxes[:, 2:4], axis=0)], axis=-1)
max_l_trans = max_bbox[0]
max_u_trans = max_bbox[1]
max_r_trans = w - max_bbox[2]
max_d_trans = h - max_bbox[3]
crop_xmin = max(0, int(max_bbox[0] - random.uniform(0, max_l_trans)))
crop_ymin = max(0, int(max_bbox[1] - random.uniform(0, max_u_trans)))
crop_xmax = max(w, int(max_bbox[2] + random.uniform(0, max_r_trans)))
crop_ymax = max(h, int(max_bbox[3] + random.uniform(0, max_d_trans)))
image = image[crop_ymin : crop_ymax, crop_xmin : crop_xmax]
bboxes[:, [0, 2]] = bboxes[:, [0, 2]] - crop_xmin
bboxes[:, [1, 3]] = bboxes[:, [1, 3]] - crop_ymin
return image, bboxes3.随机移动图像
'''
随机移动图像
'''
def random_translate(self, image, bboxes):
if random.random() < 0.5:
h, w, _ = image.shape
max_bbox = np.concatenate([np.min(bboxes[:, 0:2], axis=0), np.max(bboxes[:, 2:4], axis=0)], axis=-1)
max_l_trans = max_bbox[0]
max_u_trans = max_bbox[1]
max_r_trans = w - max_bbox[2]
max_d_trans = h - max_bbox[3]
tx = random.uniform(-(max_l_trans - 1), (max_r_trans - 1))
ty = random.uniform(-(max_u_trans - 1), (max_d_trans - 1))
M = np.array([[1, 0, tx], [0, 1, ty]])
image = cv2.warpAffine(image, M, (w, h))
bboxes[:, [0, 2]] = bboxes[:, [0, 2]] + tx
bboxes[:, [1, 3]] = bboxes[:, [1, 3]] + ty
return image, bboxes
- preprocess_true_boxes(bboxes)函数
该函数主要是对标记框进行预处理，根据有无物体，及anchor和GT的IOU初始化置信度和分类概率，细节还需要看代码理解。
'''
标记框预处理
'''
def preprocess_true_boxes(self, bboxes):
# train_output_sizes[i] =》 52 ，26，13三个值
label = [np.zeros((self.train_output_sizes[i], self.train_output_sizes[i], self.anchor_per_scale,
5 + self.num_classes)) for i in range(3)]
bboxes_xywh = [np.zeros((self.max_bbox_per_scale, 4)) for _ in range(3)] # 3,150,4
bbox_count = np.zeros((3,))
for bbox in bboxes:
bbox_coor = bbox[:4] # 取x1,y1,x2,y2
bbox_class_ind = bbox[4] # 取类别序号
onehot = np.zeros(self.num_classes, dtype=np.float) # onehot [0,0,1,0,0...]
onehot[bbox_class_ind] = 1.0 # 将类别索引出置为1
uniform_distribution = np.full(self.num_classes, 1.0 / self.num_classes) # num_classes维，每维以类别总数的倒数填充
deta = 0.01
smooth_onehot = onehot * (1 - deta) + deta * uniform_distribution
# 根据x1,y1,x2,y2计算得出x,y,w,h，（x,y）为矩形框中心点坐标，相对于下采样前图的坐标
bbox_xywh = np.concatenate([(bbox_coor[2:] + bbox_coor[:2]) * 0.5, bbox_coor[2:] - bbox_coor[:2]], axis=-1)
# 除以下采样率，对应到特征图上的坐标，包含小中大三个尺寸信息
bbox_xywh_scaled = 1.0 * bbox_xywh[np.newaxis, :] / self.strides[:, np.newaxis]
iou = []
exist_positive = False # 存在标记框
for i in range(3):
anchors_xywh = np.zeros((self.anchor_per_scale, 4)) # anchor_per_scale每个框产生几个anchor
anchors_xywh[:, 0:2] = np.floor(bbox_xywh_scaled[i, 0:2]).astype(np.int32) + 0.5 # np.floor()向下取整
anchors_xywh[:, 2:4] = self.anchors[i] # 获取基准anchor的宽高
iou_scale = self.bbox_iou(bbox_xywh_scaled[i][np.newaxis, :], anchors_xywh) # 计算缩放后的GT与anchor框的IOU
iou.append(iou_scale)
iou_mask = iou_scale > 0.3 # 大于0.3为1，否则为0
if np.any(iou_mask): # 有1个非0
xind, yind = np.floor(bbox_xywh_scaled[i, 0:2]).astype(np.int32) # 标记框中心坐标
# # 减少数据敏感性， 9月19号添加，可以打开，不影响结果。
xind, yind = abs(xind), abs(yind)
if yind >= label[i].shape[1]: # shape[1] 13，26,52
yind = label[i].shape[1] - 1
if xind >= label[i].shape[0]: # shape[0] 13，26,52
xind = label[i].shape[0] - 1
label[i][yind, xind, iou_mask, :] = 0 # 先初始化为0
label[i][yind, xind, iou_mask, 0:4] = bbox_xywh # 标记框的坐标信息
label[i][yind, xind, iou_mask, 4:5] = 1.0 # 置信度
label[i][yind, xind, iou_mask, 5:] = smooth_onehot # 分类概率
bbox_ind = int(bbox_count[i] % self.max_bbox_per_scale)
bboxes_xywh[i][bbox_ind, :4] = bbox_xywh # 第i个box的标记框
bbox_count[i] += 1
exist_positive = True
if not exist_positive: # 没有标记框，找iou最大值
best_anchor_ind = np.argmax(np.array(iou).reshape(-1), axis=-1) # 找iou最大值
best_detect = int(best_anchor_ind / self.anchor_per_scale)
best_anchor = int(best_anchor_ind % self.anchor_per_scale)
xind, yind = np.floor(bbox_xywh_scaled[best_detect, 0:2]).astype(np.int32)
# 减少数据敏感性 9月19号添加
xind, yind = abs(xind), abs(yind)
if yind >= label[best_detect].shape[1]:
yind = label[best_detect].shape[1] - 1
if xind >= label[best_detect].shape[0]:
xind = label[best_detect].shape[0] - 1
label[best_detect][yind, xind, best_anchor, :] = 0
label[best_detect][yind, xind, best_anchor, 0:4] = bbox_xywh # 标记框坐标
label[best_detect][yind, xind, best_anchor, 4:5] = 1.0 # 置信度
label[best_detect][yind, xind, best_anchor, 5:] = smooth_onehot # 分类概率
bbox_ind = int(bbox_count[best_detect] % self.max_bbox_per_scale)
bboxes_xywh[best_detect][bbox_ind, :4] = bbox_xywh
bbox_count[best_detect] += 1
label_sbbox, label_mbbox, label_lbbox = label # 获取小中大标记框的标签
sbboxes, mbboxes, lbboxes = bboxes_xywh # 获取小中大标记框的坐标值
return label_sbbox, label_mbbox, label_lbbox, sbboxes, mbboxes, lbboxes以上是数据预处理部分的代码，并没有贴全部，只是按主要框架贴了出来。
