【YOLO入门】 YOLO_V1源文件学习

梦里梦外; 2022-03-29 17:56 476阅读 0赞

**目录**

0 前言

1 YOLO\_V1代码预览

2 train解析

2.1 先看一下导入的文件

2.2 main函数开始

2.2 YOLONet

2.3 pascal\_voc

--------------------

# 0 前言 #

之前陆续已经实现了如何使用YOLOV3，YOLOV1进行目标检测，这两天想抽时间，学习一下官方的原源文件，补充一下理论知识。本文使用的源码来源于 [https://github.com/hizhangp/yolo\_tensorflow][https_github.com_hizhangp_yolo_tensorflow] 。

# 1 YOLO\_V1代码预览 #

由上面提供的链接，下载解压后，源文件的构成如下图，

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BsU29uZ19DU0RO_size_16_color_FFFFFF_t_70][]

一共有9个对象，其中三个文件夹，6个文件。

**3个文件夹**

test：存放的用于测试的图片

yolo：里面有三个文件

yolo\_net.py：建立yolo网络（YOLONet）yolo\_net.py定义了YOLONet类，该类包含了网络的的初始化（\_\_init\_\_()），建立网络（build\_networks()），和loss函数（loss\_layer()）等方法。

config.py:路径和数据集参数设置

\_\_init\_\_.py:空文件

utils：里面有三个文件

pascal\_voc.py：读取文件数据

\_\_init\_\_.py：空文件

timer.py:用于计时

**6个文件**

train.py：训练代码

test.py：测试代码

README：为帮助说明文件

LICENSE：证书

download\_data.sh：应该是于下载数据有关的文件，待研究...

.gitignore：使用github提交本地代码时，忽略不必要提交的文件

# 2 train解析 #

train是用来训练网络的。

看眼train.py文件的整体框架，如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BsU29uZ19DU0RO_size_16_color_FFFFFF_t_70 1][] trian.py整体框架

## 2.1 先看一下导入的文件 ##

import os # 操作系统操作模块
    import argparse # python中的命令行解析模块
    import datetime # 处理日期和时间的标准库
    import tensorflow as tf # tensorflow框架
    import yolo.config as cfg # yolo文件夹下的config.py配置文件
    from yolo.yolo_net import YOLONet # yolo文件夹下的yolo_net.py网络构建文件
    from utils.timer import Timer # utils文件夹下的timer.py计时文件
    from utils.pascal_voc import pascal_voc # utils文件夹下的pascal_voc.py文件读取数据模块
    
    slim = tf.contrib.slim #可以大大减少复杂网络的代码量

## 2.2 main函数开始 ##

def main():
        #用于解析命令行，显示帮助信息，直到......
        parser = argparse.ArgumentParser()
        parser.add_argument('--weights', default="YOLO_small.ckpt", type=str)
        parser.add_argument('--data_dir', default="data", type=str)
        parser.add_argument('--threshold', default=0.2, type=float)
        parser.add_argument('--iou_threshold', default=0.5, type=float)
        parser.add_argument('--gpu', default='', type=str)
        args = parser.parse_args()
    
        if args.gpu is not None:
            cfg.GPU = args.gpu
    
        if args.data_dir != cfg.DATA_PATH:
            update_config_paths(args.data_dir, args.weights)
    
        os.environ['CUDA_VISIBLE_DEVICES'] = cfg.GPU
        #......这里
    
        yolo = YOLONet() # 实例化YOLONet对象。YOLONet是在yolo_net.py文件中定义的类
        pascal = pascal_voc('train') # 实例化pascal_voc对象。pascal_voc是在pascal_voc.py中定义的类
    
        solver = Solver(yolo, pascal) # 实例化Solver对象。Solver是在本文件中定义的类
    
        print('Start training ...')
        solver.train() #调用solver对象的train方法，执行训练。
        print('Done training.')

main()函数的前部分,使用argparser模块显示帮助信息，提示用户的。

运行效果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BsU29uZ19DU0RO_size_16_color_FFFFFF_t_70 2][]

由于本人的电脑显存较小，运行时报错了：ResourceExhaustedError

应该可以修改参数，完成，在yolo\_v3训练时候，就是通过修改batchsize和epoch来实现。

main()函数的下半部分分别调用了使用YOLONet，pascal\_voc Solver以及train()方法。下面依次进行介绍。

## 2.2 YOLONet ##

同样先看一下yolo\_net.py文件的框架

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BsU29uZ19DU0RO_size_16_color_FFFFFF_t_70 3][] yolo\_net.py

**两大任务：定义YOLONet()类，和激活函数leaky\_relu()**

关于leaky\_relu(）激活函数参看 [激活函数][Link 1]

下面是大佬**YOLONet()类**上场。按照惯例，先一睹风采。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BsU29uZ19DU0RO_size_16_color_FFFFFF_t_70 4][]

def \_\_init\_\_(): 网络初始化，包含了网络初始的参数

def build\_network(): 建立网络

def calc\_iou: 计算iou（Intersection over Union）

def loss\_layer(): loss函数

看下面的注释

**\_\_init\_\_()**

def __init__(self, is_training=True):
            ##VOC 2012数据集类别名
            self.classes = cfg.CLASSES # 类别
            self.num_class = len(self.classes) #类别的数量，这里默认值20
            self.image_size = cfg.IMAGE_SIZE # 网络输入图像的尺寸默认值448，448×448
            self.cell_size = cfg.CELL_SIZE # cell尺寸，默认S = 7，将图像分为SxS的格子
            self.boxes_per_cell = cfg.BOXES_PER_CELL # 每个geid cell负责的boxes，默认为2
            ##网络输出的大小 S*S*(B*5 + C) = 1470
            self.output_size = (self.cell_size * self.cell_size) *\
                (self.num_class + self.boxes_per_cell * 5) # 输出尺寸
            #图片的缩放比例
            self.scale = 1.0 * self.image_size / self.cell_size # 1×（448÷7）
            self.boundary1 = self.cell_size * self.cell_size * self.num_class # 7×7×20
            self.boundary2 = self.boundary1 +\
                self.cell_size * self.cell_size * self.boxes_per_cell # 7×7×20 + 7×7×2
            '''
            boundery1和boundery2 作用是在输出中确定每种信息的长度（如类别，置信度等）。
            其中 boundery1 指的是对于所有的 cell 的类别的预测的张量维度，所以是 
            self.cell_size * self.cell_size * self.num_class
            boundery2 指的是在类别之后每个cell 所对应的 bounding boxes 的数量的总和，所以是
            self.boundary1 + self.cell_size * self.cell_size * self.boxes_per_cell        
            '''
    
            # 代价函数 权重
            self.object_scale = cfg.OBJECT_SCALE # 默认值1.0
            self.noobject_scale = cfg.NOOBJECT_SCALE # 默认值1.0
            self.class_scale = cfg.CLASS_SCALE # 默认值2.0
            self.coord_scale = cfg.COORD_SCALE # 默认值5.0
    
            self.learning_rate = cfg.LEARNING_RATE # 学习率，默认值0.0001
            self.batch_size = cfg.BATCH_SIZE #批次大小，默认值45
            self.alpha = cfg.ALPHA #泄露修正线性激活函数 ,m默认系数0.1
    
            # 偏置形状[7,7,2]
            self.offset = np.transpose(np.reshape(np.array(
                [np.arange(self.cell_size)] * self.cell_size * self.boxes_per_cell),
                (self.boxes_per_cell, self.cell_size, self.cell_size)), (1, 2, 0))
    
            #输入图片占位符 [NONE,image_size,image_size,3]
            self.images = tf.placeholder(
                tf.float32, [None, self.image_size, self.image_size, 3],
                name='images') #placeholder()是在网络构建graph的时的占位此时没有把输入的数据传入模型，只分配必内存
    
            #构建网络，获取YOLO网络的输出（不经过激活函数的输出），形状[None，1470]
            self.logits = self.build_network(
                self.images, num_outputs=self.output_size, alpha=self.alpha,
                is_training=is_training)
    
            if is_training:
                # 设置标签占位符 [None,S,S,5+C]  即[None,7,7,25]
                self.labels = tf.placeholder(
                    tf.float32,
                    [None, self.cell_size, self.cell_size, 5 + self.num_class])
                #设置损失函数
                self.loss_layer(self.logits, self.labels)
                #加入正则化后的损失函数
                self.total_loss = tf.losses.get_total_loss()
                # 将损失以标量形式显示，该变量命名为total_loss
                tf.summary.scalar('total_loss', self.total_loss)

**建立网络build\_network()**

def build_network(self,
                          images,
                          num_outputs,
                          alpha,
                          keep_prob=0.5,
                          is_training=True,
                          scope='yolo'):
            '''
            :param images: 输入图片占位符 [None,image_size,image_size,3]  这里是[None,448,448,3]
            :param num_outputs: 标量，网络输出节点数 1470
            :param alpha: 泄露修正线性激活函数 系数0.1
            :param keep_prob: 弃权 保留率
            :param is_training: 训练？
            :param scope: 命名空间名
            :param return:
                    返回网络的最后一层，激活函数处理之前的值  形状[None,1470]
            '''
    
            with tf.variable_scope(scope):
                with slim.arg_scope(
                    [slim.conv2d, slim.fully_connected],
                    activation_fn=leaky_relu(alpha),
                    weights_regularizer=slim.l2_regularizer(0.0005),
                    weights_initializer=tf.truncated_normal_initializer(0.0, 0.01)
                ):
    
                    '''
                    原文中是这样说的：我们的网络架构收到GoogleNet图像分类模型的启发。
                    我们的网络是有24个卷积层，后面是2个全连接层。
                    
                    总结：24个卷积层，2个全连接层，4个池化层，
                    '''
    
                    #1
                    net = tf.pad(
                        images, np.array([[0, 0], [3, 3], [3, 3], [0, 0]]),
                        name='pad_1')
                    #2 卷积层1
                    net = slim.conv2d(
                        net, 64, 7, 2, padding='VALID', scope='conv_2')
                    #3 池化层1
                    net = slim.max_pool2d(net, 2, padding='SAME', scope='pool_3')
                    #4 卷积层2
                    net = slim.conv2d(net, 192, 3, scope='conv_4')
                    #5 池化层2
                    net = slim.max_pool2d(net, 2, padding='SAME', scope='pool_5')
                    #6 卷积层3
                    net = slim.conv2d(net, 128, 1, scope='conv_6')
                    # 7卷积层4
                    net = slim.conv2d(net, 256, 3, scope='conv_7')
                    #8 卷积层5
                    net = slim.conv2d(net, 256, 1, scope='conv_8')
                    #9 卷积层6
                    net = slim.conv2d(net, 512, 3, scope='conv_9')
                    #10 池化层3
                    net = slim.max_pool2d(net, 2, padding='SAME', scope='pool_10')
                    #11 卷积层7
                    net = slim.conv2d(net, 256, 1, scope='conv_11')
                    #12 卷积层8
                    net = slim.conv2d(net, 512, 3, scope='conv_12')
                    #13 卷积层9
                    net = slim.conv2d(net, 256, 1, scope='conv_13')
                    #14 卷积层10
                    net = slim.conv2d(net, 512, 3, scope='conv_14')
                    #15 卷积层11
                    net = slim.conv2d(net, 256, 1, scope='conv_15')
                    #16 卷积层12
                    net = slim.conv2d(net, 512, 3, scope='conv_16')
                    #17 卷积层13
                    net = slim.conv2d(net, 256, 1, scope='conv_17')
                    #18 卷积层14
                    net = slim.conv2d(net, 512, 3, scope='conv_18')
                    #19 卷积层15
                    net = slim.conv2d(net, 512, 1, scope='conv_19')
                    #20 卷积层16
                    net = slim.conv2d(net, 1024, 3, scope='conv_20')
                    #21 池化层4
                    net = slim.max_pool2d(net, 2, padding='SAME', scope='pool_21')
                    #22 卷积层17
                    net = slim.conv2d(net, 512, 1, scope='conv_22')
                    #23 卷积层18
                    net = slim.conv2d(net, 1024, 3, scope='conv_23')
                    #24 卷积层19
                    net = slim.conv2d(net, 512, 1, scope='conv_24')
                    #25 卷积层20
                    net = slim.conv2d(net, 1024, 3, scope='conv_25')
                    #26 卷积层21
                    net = slim.conv2d(net, 1024, 3, scope='conv_26')
                    #27
                    net = tf.pad(
                        net, np.array([[0, 0], [1, 1], [1, 1], [0, 0]]),
                        name='pad_27')
                    #28 卷积层22
                    net = slim.conv2d(
                        net, 1024, 3, 2, padding='VALID', scope='conv_28')
                    #29 卷积层23
                    net = slim.conv2d(net, 1024, 3, scope='conv_29')
                    #30 卷积层24
                    net = slim.conv2d(net, 1024, 3, scope='conv_30')
                    #31 转置
                    net = tf.transpose(net, [0, 3, 1, 2], name='trans_31')
                    #32 展开
                    net = slim.flatten(net, scope='flat_32')
                    #33 全连接层1
                    net = slim.fully_connected(net, 512, scope='fc_33')
                    #34 全连接层2
                    net = slim.fully_connected(net, 4096, scope='fc_34')
                    #35 弃权层
                    net = slim.dropout(
                        net, keep_prob=keep_prob, is_training=is_training,
                        scope='dropout_35')
                    #36 全连接层
                    net = slim.fully_connected(
                        net, num_outputs, activation_fn=None, scope='fc_36')
    
            return net

**calc\_iou: 计算iou（Intersection over Union）**

def calc_iou(self, boxes1, boxes2, scope='iou'):
            """calculate ious
            计算两个bounding box之间的Iou。输入的是一个五维的bounding box，输出的两个boundingbox 的Iou。
            Args:
              boxes1: 5-D tensor [BATCH_SIZE, CELL_SIZE, CELL_SIZE, BOXES_PER_CELL, 4]  ====> (x_center, y_center, w, h)
              boxes2: 5-D tensor [BATCH_SIZE, CELL_SIZE, CELL_SIZE, BOXES_PER_CELL, 4] ===> (x_center, y_center, w, h)
              注意，这里的参数x_center，y_center，w，h都是归一化到[0,1]之间的，分别表示预测框的中心相对于整张图片的坐标、宽、高
            Return:
              iou: 4-D tensor [BATCH_SIZE, CELL_SIZE, CELL_SIZE, BOXES_PER_CELL]
            """
            with tf.variable_scope(scope):
                # transform (x_center, y_center, w, h) to (x1, y1, x2, y2)
                #吧以前的中心点坐标和宽度转换成左上角和右下角的两个点的坐标
                boxes1_t = tf.stack([boxes1[..., 0] - boxes1[..., 2] / 2.0,
                                     boxes1[..., 1] - boxes1[..., 3] / 2.0,
                                     boxes1[..., 0] + boxes1[..., 2] / 2.0,
                                     boxes1[..., 1] + boxes1[..., 3] / 2.0],
                                    axis=-1)
    
                boxes2_t = tf.stack([boxes2[..., 0] - boxes2[..., 2] / 2.0,
                                     boxes2[..., 1] - boxes2[..., 3] / 2.0,
                                     boxes2[..., 0] + boxes2[..., 2] / 2.0,
                                     boxes2[..., 1] + boxes2[..., 3] / 2.0],
                                    axis=-1)
    
                # calculate the left up point & right down point
                '''
                lu和rd就是分别求两个框香蕉的矩形的左上角的坐标 和 右下角的坐标，因为对于左上角，选择
               x和y是选择较大的，而右下角是选择较小的，可以想想这两个矩形相交是不是这种情况。 
                '''
                lu = tf.maximum(boxes1_t[..., :2], boxes2_t[..., :2]) #两个框相交的矩形的左上角（x1,y1）
                rd = tf.minimum(boxes1_t[..., 2:], boxes2_t[..., 2:]) #两个框相交的矩形的右下角（x2，y2）
    
                # intersection
                '''
                intersection这个就是求相交矩形的长和宽，所以有rd - ru，相当于x1 - x2和y1 - y2，
                之所以在外面还要加上一个tf.maximum是因为要删除那些不合理的框，比如两个框没有交集，就会
                出现左上角坐标比右上角还打。
                '''
                intersection = tf.maximum(0.0, rd - lu)
                inter_square = intersection[..., 0] * intersection[..., 1] #求面积
    
                # calculate the boxs1 square and boxs2 square
                '''
                计算两个框的面积，因为之前是中心点坐标和长和宽，座椅这里直接用长和宽
                '''
                square1 = boxes1[..., 2] * boxes1[..., 3]
                square2 = boxes2[..., 2] * boxes2[..., 3]
    
                '''
                union_square就是两个框的交面积，因为如果两个框的面积相加，那么就会重复了相交的部分，所以减去相交的
                部分，外面有个tf.maximum为了保证相交的部分不为0
                '''
                union_square = tf.maximum(square1 + square2 - inter_square, 1e-10)
    
            '''
            最后有一个tf.clip_by_value,这个是将如果你的交并比大于1，就让他等于1 ，如果小于0 ，就让他等于0
            ，因为交并比在[0,1]
            '''
            return tf.clip_by_value(inter_square / union_square, 0.0, 1.0)

下面就是代价函数了。

论文中：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BsU29uZ19DU0RO_size_16_color_FFFFFF_t_70 5][]

**下面看看loss\_layer()实现**

def loss_layer(self, predicts, labels, scope='loss_layer'):
            '''
            计算预测与标签的之间代价函数（损失函数）
            :param predicts: Yolo网络的输出 形状[None,1470]
            :param labels: 标签值 形状[None,7,7,25]
           '''
            with tf.variable_scope(scope):
                '''
                将网格输出分离为“类别”、“置信度”、“边界框大小”
                输出的维度为7*7*20 + 7*7*2 + 7*7*2*4 = 1470 
                '''
                #预测每个格子目标的类别，形状[45,7,7,20]
                predict_classes = tf.reshape(
                    predicts[:, :self.boundary1],
                    [self.batch_size, self.cell_size, self.cell_size, self.num_class])
    
                #预测每个格子中两个边界框的置信度 形状[45,7,7,2]
                predict_scales = tf.reshape(
                    predicts[:, self.boundary1:self.boundary2],
                    [self.batch_size, self.cell_size, self.cell_size, self.boxes_per_cell])
    
                '''
                预测每个格子中的两个边界框，(x,y)表示边界框相对于格子边界框的中心 w,h的开根号
                相对于整个图片  形状[45,7,7,2,4]
                '''
                predict_boxes = tf.reshape(
                    predicts[:, self.boundary2:],
                    [self.batch_size, self.cell_size, self.cell_size, self.boxes_per_cell, 4])
    
                #标签的置信度,表示这个地方是否有框 形状[45,7,7,1]
                response = tf.reshape(
                    labels[..., 0],
                    [self.batch_size, self.cell_size, self.cell_size, 1])
    
                # 标签的边界框 (x,y)表示边界框相对于整个图片的中心 形状[45,7,7,1，4]
                boxes = tf.reshape(
                    labels[..., 1:5],
                    [self.batch_size, self.cell_size, self.cell_size, 1, 4])
    
                # 标签的边界框 归一化后 张量沿着axis=3重复两边，扩充后[45,7,7,2,4]
                boxes = tf.tile(
                    boxes, [1, 1, 1, self.boxes_per_cell, 1]) / self.image_size
                classes = labels[..., 5:]
    
                '''
                predict_boxes_tran：offset变量用于把预测边界框predict_boxes中的坐标中心(x,y)
                由相对当前格子转换为相对当前整个图片            
                offset，这个是构造的[7,7,2]矩阵，每一行都是[7,2]的矩阵，值为
                [[0,0],[1,1],[2,2],[3,3],[4,4],[5,5],[6,6]]
                这个变量是为了将每个cell的坐标对齐，后一个框比前一个框要多加1
                比如我们预测了cell_size的每个中心点坐标，那么我们这个中心点落在第几个cell_size
                就对应坐标要加几，这个用法比较巧妙，构造了这样一个数组，让他们对应位置相加
                '''
    
                # offset shape为[1,7,7,2]  如果忽略axis=0，则每一行都是  [[0,0],[1,1],[2,2],[3,3],[4,4],[5,5],[6,6]]
                offset = tf.reshape(
                    tf.constant(self.offset, dtype=tf.float32),
                    [1, self.cell_size, self.cell_size, self.boxes_per_cell])
    
                # shape为[45,7,7,2]
                offset = tf.tile(offset, [self.batch_size, 1, 1, 1])
                # shape为[45,7,7,2]  如果忽略axis=0 第i行为[[i,i],[i,i],[i,i],[i,i],[i,i],[i,i],[i,i]]
                offset_tran = tf.transpose(offset, (0, 2, 1, 3))
    
                # shape为[45,7,7,2,4]  计算每个格子中的预测边界框坐标(x,y)相对于整个图片的位置  而不是相对当前格子
                # 假设当前格子为(3,3)，当前格子的预测边界框为(x0,y0)，则计算坐标(x,y) = ((x0,y0)+(3,3))/7
                predict_boxes_tran = tf.stack(
                    [(predict_boxes[..., 0] + offset) / self.cell_size,
                     (predict_boxes[..., 1] + offset_tran) / self.cell_size,
                     tf.square(predict_boxes[..., 2]),
                     tf.square(predict_boxes[..., 3])], axis=-1)
    
                # 计算每个格子预测边界框与真实边界框之间的IOU  [45,7,7,2]
                iou_predict_truth = self.calc_iou(predict_boxes_tran, boxes)
    
                # calculate I tensor [BATCH_SIZE, CELL_SIZE, CELL_SIZE, BOXES_PER_CELL]
    
                '''
                 这个是求论文中的1ijobj参数，[45,7,7,2]     
                 1ijobj：表示网格单元i的第j个编辑框预测器’负责‘该预测
                先计算每个框交并比最大的那个，因为我们知道，YOLO每个格子预测两个边界框，一个类别。
                在训练时，每个目标只需要
                一个预测器来负责，我们指定一个预测器"负责"，根据哪个预测器与真实值之间具有当前最高的IOU来预测目标。
                所以object_mask就表示每个格子中的哪个边界框负责该格子中目标预测？
                哪个边界框取值为1，哪个边界框就负责目标预测
                当格子中的确有目标时，取值为[1,1]，[1,0],[0,1]
                比如某一个格子的值为[1,0]，表示第一个边界框负责该格子目标的预测  
                [0,1]：表示第二个边界框负责该格子目标的预测
                当格子没有目标时，取值为[0,0]
                '''
                object_mask = tf.reduce_max(iou_predict_truth, 3, keep_dims=True)
                object_mask = tf.cast(
                    (iou_predict_truth >= object_mask), tf.float32) * response
    
                # calculate no_I tensor [CELL_SIZE, CELL_SIZE, BOXES_PER_CELL]
                # calculate no_I tensor [CELL_SIZE, CELL_SIZE, BOXES_PER_CELL]
                # noobject_mask就表示每个边界框不负责该目标的置信度，
                # 使用tf.onr_like，使得全部为1,再减去有目标的，也就是有目标的对应坐标为1,这样一减，就变为没有的了。[45,7,7,2]
                noobject_mask = tf.ones_like(
                    object_mask, dtype=tf.float32) - object_mask
                # boxes_tran 这个就是把之前的坐标换回来(相对整个图像->相对当前格子)，长和宽开方(原因在论文中有说明)，
                # 后面求loss就方便。 shape为(4, 45, 7, 7, 2)
                boxes_tran = tf.stack(
                    [boxes[..., 0] * self.cell_size - offset,
                     boxes[..., 1] * self.cell_size - offset_tran,
                     tf.sqrt(boxes[..., 2]),
                     tf.sqrt(boxes[..., 3])], axis=-1)
    
                # class_loss分类损失，如果目标出现在网格中 response为1，否则response为0  原文代价函数公式第5项
                # 该项表名当格子中有目标时，预测的类别越接近实际类别，代价值越小  原文代价函数公式第5项
                class_delta = response * (predict_classes - classes)
                class_loss = tf.reduce_mean(
                    tf.reduce_sum(tf.square(class_delta), axis=[1, 2, 3]),
                    name='class_loss') * self.class_scale
    
                # object_loss 有目标物体存在的置信度预测损失   原文代价函数公式第3项
                #该项表名当格子中有目标时，负责该目标预测的边界框的置信度越越接近预测的边界框与实际边界框之间的IOU时，代价值越小
                object_delta = object_mask * (predict_scales - iou_predict_truth)
                object_loss = tf.reduce_mean(
                    tf.reduce_sum(tf.square(object_delta), axis=[1, 2, 3]),
                    name='object_loss') * self.object_scale
    
                # noobject_loss没有目标物体存在的置信度的损失(此时iou_predict_truth为0)  原文代价函数公式第4项
                #该项表名当格子中没有目标时，预测的两个边界框的置信度越接近0，代价值越小
                noobject_delta = noobject_mask * predict_scales
                noobject_loss = tf.reduce_mean(
                    tf.reduce_sum(tf.square(noobject_delta), axis=[1, 2, 3]),
                    name='noobject_loss') * self.noobject_scale
    
                # coord_loss边界框坐标损失 shape 为 [batch_size, 7, 7, 2, 1]  原文代价函数公式1,2项
                #该项表名当格子中有目标时，预测的边界框越接近实际边界框，代价值越小
                coord_mask = tf.expand_dims(object_mask, 4)
                boxes_delta = coord_mask * (predict_boxes - boxes_tran)
                coord_loss = tf.reduce_mean(
                    tf.reduce_sum(tf.square(boxes_delta), axis=[1, 2, 3, 4]),
                    name='coord_loss') * self.coord_scale
    
                # 将所有损失放在一起 
                tf.losses.add_loss(class_loss)
                tf.losses.add_loss(object_loss)
                tf.losses.add_loss(noobject_loss)
                tf.losses.add_loss(coord_loss)
    
                # 将每个损失添加到日志记录
                tf.summary.scalar('class_loss', class_loss)
                tf.summary.scalar('object_loss', object_loss)
                tf.summary.scalar('noobject_loss', noobject_loss)
                tf.summary.scalar('coord_loss', coord_loss)
    
                tf.summary.histogram('boxes_delta_x', boxes_delta[..., 0])
                tf.summary.histogram('boxes_delta_y', boxes_delta[..., 1])
                tf.summary.histogram('boxes_delta_w', boxes_delta[..., 2])
                tf.summary.histogram('boxes_delta_h', boxes_delta[..., 3])
                tf.summary.histogram('iou', iou_predict_truth)

暂时看不懂，先放放，以再细细研究。

至此，yolo\_net.py介绍完毕。

## 2.3 pascal\_voc ##

下面开始啃 pascal\_voc

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BsU29uZ19DU0RO_size_16_color_FFFFFF_t_70 6][] pascal\_voc.py

还记得上面，我们在YOLONet类中定义了两个占位符，一个输入图片的占位符，一个是图片对应的标签的占位符。如下：

#输入图片占位符 [NONE,image_size,image_size,3]
            self.images = tf.placeholder(
                tf.float32, [None, self.image_size, self.image_size, 3],
                name='images') #placeholder()是在网络构建graph的时的占位此时没有把输入的数据传入模型，只分配必内存
    
            #构建网络，获取YOLO网络的输出（不经过激活函数的输出），形状[None，1470]
            self.logits = self.build_network(
                self.images, num_outputs=self.output_size, alpha=self.alpha,
                is_training=is_training)
    
            if is_training:
                # 设置标签占位符 [None,S,S,5+C]  即[None,7,7,25]
                self.labels = tf.placeholder(
                    tf.float32,
                    [None, self.cell_size, self.cell_size, 5 + self.num_class])
               ...

而pascal\_voc.py问价你的母的就是为了准备数据，赋值给占位符。在pascal\_voc.py文件中，定义了一个pascal\_voc类，该类包含了

def \_\_init\_\_()：类初始化函数

def get(): 批量数据读取函数

def image\_read(): 图片读取函数

def prepare(): 数据准备函数

def load\_lables(): 加载所有数据集的标签

def load\_pascal\_annotation():。。。

**先看初始化函数\_\_init\_\_()**

def __init__(self, phase, rebuild=False):
            '''
            初始化
            :param phase: 传入字符串，'train':训练，'test：'：测试
            :param rebuild: 是否重新创建数据集的标签文件，保存在缓存的目录下
            '''
            self.devkil_path = os.path.join(cfg.PASCAL_PATH, 'VOCdevkit') # VOCdevkit文件夹路径
            self.data_path = os.path.join(self.devkil_path, 'VOC2007') #VOC2007文件夹路径
            self.cache_path = cfg.CACHE_PATH #catch文件所在路径
            self.batch_size = cfg.BATCH_SIZE  #批大小
            self.image_size = cfg.IMAGE_SIZE  #输入图像大小
            self.cell_size = cfg.CELL_SIZE #单元格大小
            self.classes = cfg.CLASSES #voc数据类别名
            # 类别名->索引的dict
            self.class_to_ind = dict(zip(self.classes, range(len(self.classes))))
            self.flipped = cfg.FLIPPED #图片是否采用水平镜像扩充训练集？
            self.phase = phase #选择训练还是测试
            self.rebuild = rebuild #是否重新创建数据集标签文件
            self.cursor = 0 #从gt_labels加载数据，cursor表明当前读取到第几个
            self.epoch = 1 #存放当前训练的轮数
            '''
            存放数据集的标签 是一个list 每一个元素都是一个dict，对应一个图片 
            如果我们在配置文件中指定flipped=True，则数据集会扩充一倍，每一张原始图片都有一个水平对称的镜像文件
                  imname：图片路径 
                  label：图片标签
                  flipped：图片水平镜像
            '''
            self.gt_labels = None
            # 加载数据集标签  初始化gt_labels
            self.prepare()

**get():批量数据读取函数**

def get(self):
            #加载数据集，每次读取batch大小的图片以及图片对应的标签
            # 返回的是 images:读取到的图片数据 [45,448,448,3]
            #        labels:对应的图片标签 [45,7,7,25]
            images = np.zeros(
                (self.batch_size, self.image_size, self.image_size, 3))
            labels = np.zeros(
                (self.batch_size, self.cell_size, self.cell_size, 25))
            count = 0
            #一次加载batch_size个图片数据，
            while count < self.batch_size:
                imname = self.gt_labels[self.cursor]['imname'] #获取图片路径
                flipped = self.gt_labels[self.cursor]['flipped'] #是否使用水平镜像
                images[count, :, :, :] = self.image_read(imname, flipped) #读取图片数据
                labels[count, :, :, :] = self.gt_labels[self.cursor]['label'] #读取图片标签
                count += 1
                self.cursor += 1
                #如果读取完一轮数据，则当前cursor置为0，当前训练轮数+1
                if self.cursor >= len(self.gt_labels):
                    #打乱数据集
                    np.random.shuffle(self.gt_labels)
                    self.cursor = 0
                    self.epoch += 1
            return images, labels

**image\_read():图片读取函数**

def image_read(self, imname, flipped=False):
            '''
            图片读取函数，先读取图片，先后缩放，转换为RGB格式，在对数据进行归一化处理
            :param imname: 图片路径
            :param flipped: 是否水平镜像处理
            :return: 图片数据[448,448,3]
            '''
            image = cv2.imread(imname)
            image = cv2.resize(image, (self.image_size, self.image_size)) #缩放处理
            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB).astype(np.float32) #BRG转RGB,uint转float32
            image = (image / 255.0) * 2.0 - 1.0  #归一化处理
    
            # 宽倒序  即水平镜像
            if flipped:
                image = image[:, ::-1, :]
            return image

**prepare()：数据准备函数**

def prepare(self):
            '''
            初始化数据标签，保存在变量gt_labels中，
            :return: gt_labels：返回数据集的标签，是一个list 每个元素对应一张图片，是一个dict
            '''
            # 加载数据集的标签
            gt_labels = self.load_labels()
            #如果水平镜像，则追加一倍的训练数据集
            if self.flipped:
                print('Appending horizontally-flipped training examples ...')
                gt_labels_cp = copy.deepcopy(gt_labels)
                # 遍历每一个图片标签
                for idx in range(len(gt_labels_cp)):
                    # 设置flipped属性为True
                    gt_labels_cp[idx]['flipped'] = True
                    gt_labels_cp[idx]['label'] =\
                        gt_labels_cp[idx]['label'][:, ::-1, :]
                    for i in range(self.cell_size):
                        for j in range(self.cell_size):
                            # 置信度==1，表示这个格子有目标
                            if gt_labels_cp[idx]['label'][i, j, 0] == 1:
                                gt_labels_cp[idx]['label'][i, j, 1] = \
                                    self.image_size - 1 -\
                                    gt_labels_cp[idx]['label'][i, j, 1]
                #追加数据集的标签，后面的是由原数据集标签标签扩充的水平镜像数据集标签
                gt_labels += gt_labels_cp
            #打乱数据集的标签
            np.random.shuffle(gt_labels)
            self.gt_labels = gt_labels
            return gt_labels

**load\_labels()：加载标签**

def load_labels(self):
            '''
            加载数据集标签
            :return: gt_labels：是一个list，每一张元素对应一张图片，是一个dict
            '''
    
            #缓冲文件名，即用来保存数据集标签的文件
            cache_file = os.path.join(
                self.cache_path, 'pascal_' + self.phase + '_gt_labels.pkl')
    
            #文件存在，且不重新创建，直接读取
            if os.path.isfile(cache_file) and not self.rebuild:
                print('Loading gt_labels from: ' + cache_file)
                with open(cache_file, 'rb') as f:
                    gt_labels = pickle.load(f)
                return gt_labels
    
            print('Processing gt_labels from: ' + self.data_path)
    
            # 若文件目录不存在，创建
            if not os.path.exists(self.cache_path):
                os.makedirs(self.cache_path)
    
            #获取训练测试集的数据文件名
            if self.phase == 'train':
                txtname = os.path.join(
                    self.data_path, 'ImageSets', 'Main', 'trainval.txt')
            # 获取测试集的数据文件名
            else:
                txtname = os.path.join(
                    self.data_path, 'ImageSets', 'Main', 'test.txt')
            with open(txtname, 'r') as f:
                self.image_index = [x.strip() for x in f.readlines()]
    
            # 存放图片的标签，图片路径，是否使用水平镜像？
            gt_labels = []
            #遍历每一张图片的信息
            for index in self.image_index:
                #读取每一张图片的标签
                label, num = self.load_pascal_annotation(index)
                if num == 0:
                    continue
                # 图片文件路径
                imname = os.path.join(self.data_path, 'JPEGImages', index + '.jpg')
                #保存该图片信息
                gt_labels.append({'imname': imname,
                                  'label': label,
                                  'flipped': False})
            print('Saving gt_labels to: ' + cache_file)
            #保存
            with open(cache_file, 'wb') as f:
                pickle.dump(gt_labels, f)
            return gt_labels

**load\_pascal\_annotation()获取图像及边界框信息**

def load_pascal_annotation(self, index):
            """
            Load image and bounding boxes info from XML file in the PASCAL VOC
            format.
            从数据集的XML文件中获取图像以及边界框信息
            index：图片文件的index
             return label, len(objs)
             label：标签
             len(objs)：对象长度
            """
            # 获取图片文件名路径
            imname = os.path.join(self.data_path, 'JPEGImages', index + '.jpg') #所以，图片必须是jpg格式的
            im = cv2.imread(imname)
    
            ##宽和高缩放比例
            h_ratio = 1.0 * self.image_size / im.shape[0]
            w_ratio = 1.0 * self.image_size / im.shape[1]
            # im = cv2.resize(im, [self.image_size, self.image_size])
    
            # 用于保存图片文件的标签
            label = np.zeros((self.cell_size, self.cell_size, 25))
            # 图片文件的标注xml文件
            filename = os.path.join(self.data_path, 'Annotations', index + '.xml')
            tree = ET.parse(filename)
            objs = tree.findall('object')
    
            for obj in objs:
                bbox = obj.find('bndbox')
                # Make pixel indexes 0-based
                #当图片缩放到image_size时，边界框也进行同比例缩放
                x1 = max(min((float(bbox.find('xmin').text) - 1) * w_ratio, self.image_size - 1), 0)
                y1 = max(min((float(bbox.find('ymin').text) - 1) * h_ratio, self.image_size - 1), 0)
                x2 = max(min((float(bbox.find('xmax').text) - 1) * w_ratio, self.image_size - 1), 0)
                y2 = max(min((float(bbox.find('ymax').text) - 1) * h_ratio, self.image_size - 1), 0)
                # 根据图片的分类名 ->类别index 转换
                cls_ind = self.class_to_ind[obj.find('name').text.lower().strip()]
                # 计算边框中心点x,y,w,h(没有归一化)
                boxes = [(x2 + x1) / 2.0, (y2 + y1) / 2.0, x2 - x1, y2 - y1]
                # 计算当前物体的中心在哪个格子中
                x_ind = int(boxes[0] * self.cell_size / self.image_size)
                y_ind = int(boxes[1] * self.cell_size / self.image_size)
                # 表明该图片已经初始化过了
                if label[y_ind, x_ind, 0] == 1:
                    continue
                # 置信度，表示这个地方有物体
                label[y_ind, x_ind, 0] = 1
                # 物体边界框
                label[y_ind, x_ind, 1:5] = boxes
                # 物体的类别
                label[y_ind, x_ind, 5 + cls_ind] = 1
    
            return label, len(objs)

至此，pascal\_voc.py解读完毕。

[https_github.com_hizhangp_yolo_tensorflow]: https://github.com/hizhangp/yolo_tensorflow
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BsU29uZ19DU0RO_size_16_color_FFFFFF_t_70]: /images/20220329/ec6786cd87b9473299337dbc90403734.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BsU29uZ19DU0RO_size_16_color_FFFFFF_t_70 1]: /images/20220329/ff47d16e84f44a83bcf8ce458f16b870.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BsU29uZ19DU0RO_size_16_color_FFFFFF_t_70 2]: /images/20220329/7b10ae23c7b545b7b1e17489b8261022.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BsU29uZ19DU0RO_size_16_color_FFFFFF_t_70 3]: /images/20220329/a18efc9808d641848a48691480a5bbb5.png
[Link 1]: https://blog.csdn.net/plSong_CSDN/article/details/86159451
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BsU29uZ19DU0RO_size_16_color_FFFFFF_t_70 4]: /images/20220329/c819c2fd597e4327af80944843c0c7e9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BsU29uZ19DU0RO_size_16_color_FFFFFF_t_70 5]: /images/20220329/e253a72a9f88459ab80ca8d56a8673f8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BsU29uZ19DU0RO_size_16_color_FFFFFF_t_70 6]: /images/20220329/e2dfaf3856d04e7f80c637b37f65bfeb.png