devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

经典目标检测YOLOV1理论基础的编码实现（通过编码理解原理）

作者：从前慢现在也慢 | 2024-04-24 17:05:44

赞

踩

经典目标检测YOLOV1理论基础的编码实现（通过编码理解原理）

目录

正文：

1、前期准备

1.1  创建目录结构

1.2  数据集介绍与下载

1.2.1 数据集介绍

1.2.1 数据集下载

1.3. 数据集处理

1.4. 构建数据加载器 

1.4.1定义初始化方法

1.4.2 定义增强图片方法

1.4.3 定义编码器

1.4.4 完整代码

1.5、定义主函数

2构建网络

2.1 ResNet架构介绍

2.2 构建ResNet

2.2.1 构建Base_Block

__init__ 函数

forward 函数

2.2.2 构建Senior_Block

__init__ 初始化函数

forward 前向传播函数

2.2.3 构建Output_Block

__init__ 初始化函数

forward 前向传播函数

2.2.4 构建ResNet

__init__ 初始化函数

_make_layer 方法

_make_out_layer 方法

forward 方法

初始化模型参数部分

2.3 定义模型

2.4 完整代码

 3、定义损失

4、定义训练过程

5、定义预测方法

6、验证图片

7、完整代码和权重下载
​​​​​​​

       为了更详细的了解Yolo的实现原理，通过YOLO的代码形式进行一步一步说明，在阅读代码的过程中，按照下面的目录的步骤去看代码。但在看代码之前建议先去简单的了解YOLO的原理，在了解之后通过下面的内容进一步验证yolo的实现过程，同时也了解了ResNet的实现过程。

       YOLO的原理参考通道1

       YOLO的原理参考通道2

正文：

1、前期准备

准备好目录结构、数据集和关于YOLOv1的基础认知

1.1  创建目录结构

        自己创建项目目录结构，结构目录如下：

network                    CNN Backbone 存放位置
weights                    权重存放的位置
test_images             测试用的图片
utils                          辅助功能的代码存放位置 

models                    保存模型位置

data                         训练的数据集

1.2  数据集介绍与下载

1.2.1 数据集介绍

       首先了解数据集，对数据集了解后方便对数据进行相应处理。数据集详细介绍直通车：https://blog.csdn.net/qq_41946216/article/details/137683750?spm=1001.2014.3001.5501

1.2.1 数据集下载

       本次采用数据集： VOC2012数据集。

       数据集下载方式一：http://host.robots.ox.ac.uk/pascal/VOC/voc2012/VOCtrainval_11-May-2012.tar

       数据集下载方式二：

     下载并构建VOC2012数据集，从：https://gitee.com/ppov-nuc/pascal-vocdataset_-for_-yolo.git， 下载get_data文件和generate_csv.py文件到本地，放到创建的目录结构中，修改get_data中下载的内容和相应路径，然后运行批处理文件get_data,在get_dat中会自动执行generate_csv.py，如下图所示。


1.3. 数据集处理

       在utils目录下创建工具类 generate_txt_file.py，主要用于数据集的划分和解析 Annotations/xxxxx.xml 文件中的类别和bbox信息，并将信息存入voctrain.txt和voctest.txt文件，如下图所示：

具体代码：

  1. # author: baiCai
  2. # 1. 导包
  3. from xml.etree import ElementTree as ET
  4. import os
  5. import random
  6.  
  7. # 2. 定义一些基本的参数
  8. # 定义所有的类名
  9. VOC_CLASSES = (
  10.     'aeroplane', 'bicycle', 'bird', 'boat',
  11.     'bottle', 'bus', 'car', 'cat', 'chair',
  12.     'cow', 'diningtable', 'dog', 'horse',
  13.     'motorbike', 'person', 'pottedplant',
  14.     'sheep', 'sofa', 'train', 'tvmonitor')
  15.  
  16. '''
  17. 读取所有 xml 文件，存入列表
  18. '''
  19. # 要读取的xml文件路径，记得自己修改路径
  20. Annotations = '../data/VOC2012/Annotations/'
  21. # 列出所有的xml文件
  22. xml_files = os.listdir(Annotations)
  23. # 打乱数据集
  24. random.shuffle(xml_files)
  25. '''
  26. 定义训练集和测试比例
  27. 划分Annotations中的训练集和测试集文件列表
  28. '''
  29. # 训练集数量
  30. train_num = int(len(xml_files) * 0.7)
  31. # 训练列表
  32. train_file_list = xml_files[:train_num]
  33. # 测测试列表
  34. test_file_list = xml_files[train_num:]
  35.  
  36. '''
  37. 定义 xml 解析后的信息存储路径和写对象
  38. '''
  39. # 训练集和测试集文件名字
  40. train_set_path = './voctrain.txt'
  41. test_set_path = './voctest.txt'
  42.  
  43. # 3. 定义解析xml文件的函数
  44. '''
  45. 主要解析 xml 获取 类别名字和bbox，如 
  46. {'name': 'person','bbox': [174, 101, 349, 351]}
  47. '''
  48. def parse_rec(filename):
  49.     # 参数：输入xml文件名
  50.     # 创建xml对象
  51.     tree = ET.parse(filename)
  52.     objects = []
  53.     # 迭代读取xml文件中的object节点，即物体信息
  54.     for obj in tree.findall('object'):
  55.         obj_struct = {}
  56.         # difficult属性，即这里不需要那些难判断的对象
  57.         difficult = int(obj.find('difficult').text)
  58.         if difficult == 1:  # 若为1则跳过本次循环
  59.             continue
  60.         # 开始收集信息
  61.         obj_struct['name'] = obj.find('name').text
  62.         bbox = obj.find('bndbox')
  63.         obj_struct['bbox'] =\
  64.             [int(float(bbox.find('xmin').text)),
  65.             int(float(bbox.find('ymin').text)),
  66.             int(float(bbox.find('xmax').text)),
  67.             int(float(bbox.find('ymax').text))]
  68.         objects.append(obj_struct)
  69.  
  70.     return objects
  71.  
  72. # 4. 把信息保存入文件中
  73. def write_txt(file_list,set_path):
  74.     # # 生成训练集txt
  75.     count = 0
  76.     with  open(set_path, 'w') as wt:
  77.         for xml_file in file_list:
  78.             count += 1
  79.             # 获取图片名字
  80.             image_name = xml_file.split('.')[0] + '.jpg'  # 图片文件名
  81.             # 对xml_file进行解析
  82.             results = parse_rec(Annotations + xml_file)
  83.             # 如果返回的对象为空，表示张图片难以检测，因此直接跳过
  84.             if len(results) == 0:
  85.                 print(xml_file)
  86.                 continue
  87.             # 否则，则写入文件中
  88.             # 先写入图片名字
  89.             wt.write(image_name)
  90.             # 接着指定下面写入的格式
  91.             for result in results:
  92.                 class_name = result['name']
  93.                 bbox = result['bbox']
  94.                 class_name = VOC_CLASSES.index(class_name)  # 名字在类别中是下标位置
  95.                 wt.write(' ' + str(bbox[0]) +
  96.                                 ' ' + str(bbox[1]) +
  97.                                 ' ' + str(bbox[2]) +
  98.                                 ' ' + str(bbox[3]) +
  99.                                 ' ' + str(class_name))
  100.             wt.write('\n')
  101.         wt.close()
  102.  
  103. # 5. 运行
  104. if __name__ == '__main__':
  105.     write_txt(train_file_list,train_set_path)
  106.     write_txt(test_file_list,test_set_path)

1.4. 构建数据加载器 

      在utils目录下创建工具类 yolo_dataset.py，主要用于数据集的构建，包含初始化、图片增强及归一化等功能。具体代码在下面完整代码中。

1.4.1定义初始化方法

       读取xxxx.xml解析后的文件
       对每行数据(每个图片信息)的所有中心点信息以【x,y,w,h】和标签分别存入box列表和label列表。
       当前图片的边界框和标签信息即box列表和label列表，转换为LongTensor格式添加到对应的boxex列表和labels列表。

1.4.2 定义增强图片方法

       增加方法如下列表：

增加方法名称定义的函数
随机翻转图片和边界框random_flip(img, boxes)
随机缩放图片和边界框randomScale(img, boxes)
随机模糊图片randomBlur(img)
随机调整图片亮度RandomBrightness(img)
随机调整图片色调RandomHue(img)
随机调整图片饱和度RandomSaturation(img)
随机移动图片和边界框randomShift(img, boxes, labels)        
随机裁剪图片和边界框randomCrop(img, boxes, labels)
用于从图像中减去均值subMean(self, bgr, mean)
将BGR图像转换为RGB图像BGR2RGB(self, img)
将BGR图像转换为HSV图像BGR2HSV(self, img)
将HSV图像转换为BGR图像HSV2BGR(self, img)

1.4.3 定义编码器

        定义编码器主要目的是用于将边界框（归一化后的边界框信息）和标签编码为目标张量。

1.4.4 完整代码

  1. # author: baiCai
  2. # 导入所需的库
  3. import os
  4. import random
  5. import numpy as np
  6. import torch
  7. import torchvision.transforms as T
  8. from torch.utils.data import Dataset
  9. import cv2
  10.  
  11.  
  12. # 定义一个Yolo数据加载器类
  13. class Yolo_Dataset(Dataset):
  14.     # 初始化默认的图片大小
  15.     image_size = 448
  16.  
  17.     def __init__(self, root, list_file, train=True, transforms=None):
  18.         ''"""
  19.         初始化函数
  20.         :param root: 图片的根目录
  21.         :param list_file: 包含图片路径和标注信息的txt文件
  22.         :param train: 是否为训练集，默认为True
  23.         :param transforms: 预处理方法，默认为None
  24.        """
  25.         # 保存传入的参数
  26.         self.root = root
  27.         self.train = train
  28.         self.transform = transforms
  29.         self.fnames = []  # 存储图片文件名
  30.         self.boxes = []  # 存储边界框信息
  31.         self.labels = []  # 存储标签信息
  32.         self.mean = (123, 117, 104)  # RGB通道的均值，用于归一化
  33.  
  34.         # 打开并读取txt文件
  35.         with open(list_file) as f:
  36.             lines = f.readlines()  # 读取所有行
  37.  
  38.         # 遍历文件中的每一行
  39.         for line in lines:
  40.             splited = line.strip().split()  # 去除行尾的空格并按空格分割
  41.             self.fnames.append(splited[0])  # 添加图片文件名到列表中
  42.  
  43.             # 计算当前行包含的对象数量，每五个数据表示一个对象
  44.             num_boxes = (len(splited) - 1) // 5
  45.  
  46.             # 初始化当前图片的边界框和标签列表
  47.             box = []
  48.             label = []
  49.  
  50.             # 遍历当前行的所有对象
  51.             for i in range(num_boxes):
  52.                 # 读取边界框的坐标信息
  53.                 x = float(splited[1 + 5 * i])
  54.                 y = float(splited[2 + 5 * i])
  55.                 x2 = float(splited[3 + 5 * i])
  56.                 y2 = float(splited[4 + 5 * i])
  57.  
  58.                 # 读取对象的类别标签
  59.                 c = splited[5 + 5 * i]
  60.  
  61.                 # 将边界框坐标添加到列表中，并转换为Tensor格式
  62.                 box.append([x, y, x2, y2])
  63.  
  64.                 # 将标签转换为整数并加1（因为标签通常从1开始计数），然后添加到列表中
  65.                 label.append(int(c) + 1)
  66.  
  67.             # 将当前图片的边界框和标签信息转换为LongTensor格式添加到对应的列表中
  68.             self.boxes.append(torch.Tensor(box))
  69.             self.labels.append(torch.LongTensor(label))
  70.  
  71.         # 记录数据集中的样本数量
  72.         self.num_samples = len(self.boxes)
  73.  
  74.     def __len__(self):
  75.         # 返回数据集中的样本数量
  76.         return self.num_samples
  77.  
  78.     # 如果是训练模式，需要进行图像的增强,idx表示每个图像在fnames列表中索引
  79.     def __getitem__(self, idx):
  80.         # 根据索引获取图片的文件名
  81.         fname = self.fnames[idx]
  82.  
  83.         # 拼接完整的图片路径并读取图片
  84.         img = cv2.imread(os.path.join(self.root, fname))
  85.  
  86.         # 获取当前图片的边界框和标签信息
  87.         boxes = self.boxes[idx].clone()
  88.         labels = self.labels[idx].clone()
  89.  
  90.         # 如果是训练模式，需要进行图像的增强
  91.         # 需要注意的是，同时处理图像和box
  92.         if self.train:
  93.             # 随机翻转图片和边界框
  94.             img, boxes = self.random_flip(img, boxes)
  95.             # 随机缩放图片和边界框
  96.             img, boxes = self.randomScale(img, boxes)
  97.             # 随机模糊图片
  98.             img = self.randomBlur(img)
  99.             # 随机调整图片亮度
  100.             img = self.RandomBrightness(img)
  101.             # 随机调整图片色调
  102.             img = self.RandomHue(img)
  103.             # 随机调整图片饱和度
  104.             img = self.RandomSaturation(img)
  105.             # 随机移动图片和边界框
  106.             img, boxes, labels = self.randomShift(img, boxes, labels)
  107.             # 随机裁剪图片和边界框
  108.             img, boxes, labels = self.randomCrop(img, boxes, labels)
  109.  
  110.         # 获取图片的高度、宽度和通道数
  111.         h, w, _ = img.shape
  112.         # 将边界框坐标除以图片宽高，进行归一化
  113.         boxes /= torch.Tensor([w, h, w, h]).expand_as(boxes)
  114.  
  115.         # 由于cv2读取图片为BGR格式，需要转换为RGB格式
  116.         img = self.BGR2RGB(img)
  117.  
  118.         # 从图片中减去RGB通道的均值
  119.         img = self.subMean(img, self.mean)
  120.  
  121.         # 将图片缩放到指定的大小，这里是448x448
  122.         img = cv2.resize(img, (self.image_size, self.image_size))
  123.         # 将边界框和标签信息编码为YOLOv1需要的格式，即7x7x30的张量
  124.         target = self.encoder(boxes, labels)
  125.  
  126.  
  127.         # 应用预定义的数据变换
  128.         for t in self.transform:
  129.             img = t(img)
  130.  
  131.             # 返回处理后的图片和编码后的目标信息
  132.         return img, target
  133.  
  134.     # 定义一个encoder方法，用于将边界框和标签编码为目标张量
  135.     def encoder(self, boxes, labels):
  136.         '''
  137.         将边界框和标签编码为7x7x30的目标张量
  139.         参数:
  140.         boxes (tensor): 形状为[[x1,y1,x2,y2],[]]的边界框张量
  141.         labels (tensor): 标签张量
  143.         返回:
  144.         target (tensor): 形状为7x7x30的目标张量
  145.         '''
  146.         grid_num = 7  # 定义网格数量
  147.         # 创建一个形状为(grid_num, grid_num, 30)的全零张量作为目标张量
  148.         target = torch.zeros((grid_num, grid_num, 30))
  149.         # 计算每个网格的缩放因子
  150.         cell_size = 1. / grid_num
  151.         print(cell_size)
  152.         print(boxes)
  153.         # 计算边界框的宽度、高度和中心点坐标，boxes 是归一化后数据
  154.         wh = boxes[:, 2:] - boxes[:, :2]
  155.         # 即 xmin ymin ，xmax，ymax 中心点坐标  (（xmax-xmin）/2，(ymax-ymin)/2))
  156.         cxcy = (boxes[:, 2:] + boxes[:, :2]) / 2
  157.  
  158.         # 遍历每个边界框的中心点
  159.         for i in range(cxcy.size()[0]):
  160.             cxcy_sample = cxcy[i]  # 获取当前边界框的中心点坐标
  161.             # 计算中心点所在的网格索引，并进行向上取整和减一操作
  162.             ij = (cxcy_sample / cell_size).ceil() - 1
  163.             # 标记目标张量中对应网格的objectness为1
  164.             target[int(ij[1]), int(ij[0]), 4] = 1
  165.             # 标记目标张量中对应网格的类别为1
  166.             target[int(ij[1]), int(ij[0]), 9] = 1
  167.             # 标记目标张量中对应网格的标签位置为1
  168.             target[int(ij[1]), int(ij[0]), int(labels[i]) + 9] = 1
  169.  
  170.             # 计算中心点在当前网格内的相对坐标
  171.             xy = ij * cell_size
  172.             # 计算中心点相对于网格左上角的偏移量
  173.             delta_xy = (cxcy_sample - xy) / cell_size
  174.  
  175.             # 填充目标张量中对应网格的宽度、高度信息
  176.             target[int(ij[1]), int(ij[0]), 2:4] = wh[i]
  177.             # 填充目标张量中对应网格的中心点偏移量信息
  178.             target[int(ij[1]), int(ij[0]), :2] = delta_xy
  179.             # 重复填充宽度、高度信息到目标张量的其他位置
  180.             target[int(ij[1]), int(ij[0]), 7:9] = wh[i]
  181.             # 重复填充中心点偏移量信息到目标张量的其他位置
  182.             target[int(ij[1]), int(ij[0]), 5:7] = delta_xy
  183.  
  184.             # 返回填充好的目标张量
  185.         return target
  186.  
  187.     # 以下是各种图像预处理方法的定义
  188.  
  189.     # 将BGR图像转换为RGB图像
  190.     def BGR2RGB(self, img):
  191.         return cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
  192.  
  193.     # 将BGR图像转换为HSV图像
  194.     def BGR2HSV(self, img):
  195.         return cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
  196.  
  197.     # 将HSV图像转换为BGR图像
  198.     def HSV2BGR(self, img):
  199.         return cv2.cvtColor(img, cv2.COLOR_HSV2BGR)
  200.  
  201.      # 随机调整图像的亮度
  202.     def RandomBrightness(self, bgr):
  203.         # 以0.5的概率调整图像的亮度
  204.         if random.random() < 0.5:
  205.             hsv = self.BGR2HSV(bgr)  # 将BGR图像转换为HSV图像
  206.             h, s, v = cv2.split(hsv)  # 分割HSV图像的通道
  207.             # 随机选择亮度调整系数
  208.             adjust = random.choice([0.5, 1.5])
  209.             v = v * adjust  # 调整亮度通道的值
  210.             # 确保亮度值在0到255之间
  211.             v = np.clip(v, 0, 255).astype(hsv.dtype)
  212.             # 合并通道得到调整后的HSV图像
  213.             hsv = cv2.merge((h, s, v))
  214.             # 将调整后的HSV图像转换回BGR图像
  215.             bgr = self.HSV2BGR(hsv)
  216.         return bgr
  217.  
  218.     # 定义一个随机调整图像饱和度的方法
  219.     def RandomSaturation(self, bgr):
  220.         # 以0.5的概率决定是否调整图像的饱和度
  221.         if random.random() < 0.5:
  222.             # 将BGR图像转换为HSV图像
  223.             hsv = self.BGR2HSV(bgr)
  224.             # 分割HSV图像的通道
  225.             h, s, v = cv2.split(hsv)
  226.             # 随机选择饱和度调整系数
  227.             adjust = random.choice([0.5, 1.5])
  228.             # 调整饱和度通道的值
  229.             s = s * adjust
  230.             # 确保饱和度值在0到255之间
  231.             s = np.clip(s, 0, 255).astype(hsv.dtype)
  232.             # 合并通道得到调整后的HSV图像
  233.             hsv = cv2.merge((h, s, v))
  234.             # 将调整后的HSV图像转换回BGR图像
  235.             bgr = self.HSV2BGR(hsv)
  236.             # 返回调整后的BGR图像
  237.         return bgr
  238.  
  239.         # 定义一个随机调整图像色调的方法
  240.  
  241.     # 随机调整图片色调
  242.     def RandomHue(self, bgr):
  243.         # 以0.5的概率决定是否调整图像的色调
  244.         if random.random() < 0.5:
  245.             # 将BGR图像转换为HSV图像
  246.             hsv = self.BGR2HSV(bgr)
  247.             # 分割HSV图像的通道
  248.             h, s, v = cv2.split(hsv)
  249.             # 随机选择色调调整系数
  250.             adjust = random.choice([0.5, 1.5])
  251.             # 调整色调通道的值
  252.             h = h * adjust
  253.             # 确保色调值在0到179之间（因为色调是循环的）
  254.             h = h % 180
  255.             # 确保色调值的数据类型与hsv图像一致
  256.             h = h.astype(hsv.dtype)
  257.             # 合并通道得到调整后的HSV图像
  258.             hsv = cv2.merge((h, s, v))
  259.             # 将调整后的HSV图像转换回BGR图像
  260.             bgr = self.HSV2BGR(hsv)
  261.             # 返回调整后的BGR图像
  262.         return bgr
  263.  
  264.     # 定义一个随机模糊图像的方法
  265.     def randomBlur(self, bgr):
  266.         # 以0.5的概率决定是否对图像进行模糊处理
  267.         if random.random() < 0.5:
  268.             # 使用cv2.blur函数对图像进行模糊处理，核大小为(5, 5)
  269.             bgr = cv2.blur(bgr, (5, 5))
  270.             # 返回模糊处理后的图像或原图像
  271.         return bgr
  272.  
  273.     # 定义一个随机平移图像的方法，同时更新边界框和标签的位置
  274.     def randomShift(self, bgr, boxes, labels):
  275.         # 计算边界框的中心点坐标
  276.         center = (boxes[:, 2:] + boxes[:, :2]) / 2
  277.  
  278.         # 以0.5的概率决定是否对图像进行平移
  279.         if random.random() < 0.5:
  280.             # 获取图像的高度、宽度和通道数
  281.             height, width, c = bgr.shape
  282.  
  283.             # 创建一个与原图同样大小的零矩阵，并填充为特定的BGR值（这里可能用于填充平移后的空白区域）
  284.             after_shfit_image = np.zeros((height, width, c), dtype=bgr.dtype)
  285.             after_shfit_image[:, :, :] = (104, 117, 123)  # 填充BGR颜色值
  286.  
  287.             # 生成随机的x和y方向的平移量，限制在图像尺寸的20%以内
  288.             shift_x = random.uniform(-width * 0.2, width * 0.2)
  289.             shift_y = random.uniform(-height * 0.2, height * 0.2)
  290.  
  291.             # 根据平移量的正负值，对图像进行不同方向的平移
  292.             if shift_x >= 0 and shift_y >= 0:
  293.                 # 当x和y都大于等于0时，从原图的右下角开始平移
  294.                 after_shfit_image[int(shift_y):, int(shift_x):, :] = bgr[:height - int(shift_y), :width - int(shift_x),
  295.                                                                      :]
  296.             elif shift_x >= 0 and shift_y < 0:
  297.                 # 当x大于等于0且y小于0时，从原图的右上方开始平移
  298.                 after_shfit_image[:height + int(shift_y), int(shift_x):, :] = bgr[-int(shift_y):, :width - int(shift_x),
  299.                                                                               :]
  300.             elif shift_x < 0 and shift_y >= 0:
  301.                 # 当x小于0且y大于等于0时，从原图的左下方开始平移
  302.                 after_shfit_image[int(shift_y):, :width + int(shift_x), :] = bgr[:height - int(shift_y), -int(shift_x):,
  303.                                                                              :]
  304.             elif shift_x < 0 and shift_y < 0:
  305.                 # 当x和y都小于0时，从原图的左上方开始平移
  306.                 after_shfit_image[:height + int(shift_y), :width + int(shift_x), :] = bgr[-int(shift_y):,
  307.                                                                                       -int(shift_x):, :]
  308.  
  309.             # 将平移量转换为Tensor格式，并扩展到与中心点坐标相同的形状
  310.             shift_xy = torch.FloatTensor([[int(shift_x), int(shift_y)]]).expand_as(center)
  311.             # 更新中心点坐标，加上平移量
  312.             center = center + shift_xy
  313.  
  314.             # 创建掩码，确保更新后的中心点坐标在图像尺寸范围内
  315.             mask1 = (center[:, 0] > 0) & (center[:, 0] < width)
  316.             mask2 = (center[:, 1] > 0) & (center[:, 1] < height)
  317.             # 合并两个掩码，得到同时满足两个条件的掩码
  318.             mask = (mask1 & mask2).view(-1, 1)
  319.  
  320.             # 根据掩码筛选出更新后仍在图像内的边界框
  321.             boxes_in = boxes[mask.expand_as(boxes)].view(-1, 4)
  322.  
  323.             # 如果经过平移后，没有边界框留在图像内，则直接返回原图像、原边界框和原标签
  324.             if len(boxes_in) == 0:
  325.                 return bgr, boxes, labels
  326.  
  327.            # 创建一个Tensor，用于存储平移量，其中x和y的平移量分别对应边界框的左上角和右下角
  328.             box_shift = torch.FloatTensor([[int(shift_x), int(shift_y), int(shift_x), int(shift_y)]]).expand_as(
  329.                 boxes_in)
  330.  
  331.             # 将平移量加到更新后的边界框上，注意这里是对边界框的四个坐标都进行了平移
  332.             boxes_in = boxes_in + box_shift
  333.  
  334.             # 根据掩码筛选出更新后仍在图像内的标签
  335.             labels_in = labels[mask.view(-1)]
  336.  
  337.             # 返回处理后的图像、更新后的边界框和标签
  338.             return after_shfit_image, boxes_in, labels_in
  339.  
  340.         # 如果不需要进行平移，或者平移后逻辑没有进入if条件块，则直接返回原图像、原边界框和原标签
  341.         return bgr, boxes, labels
  342.  
  343.     # 定义randomScale方法，用于对图像进行随机尺度变换
  344.     def randomScale(self, bgr, boxes):
  345.         # 如果随机生成的小于0.5的数，则执行尺度变换
  346.         if random.random() < 0.5:
  347.             # 生成0.8到1.2之间的随机尺度因子
  348.             scale = random.uniform(0.8, 1.2)
  349.             # 获取图像的高度、宽度和通道数
  350.             height, width, c = bgr.shape
  351.             # 使用cv2的resize函数，固定高度不变，按照生成的尺度因子调整宽度
  352.             bgr = cv2.resize(bgr, (int(width * scale), height))
  353.             # 创建一个Tensor，用于存储尺度因子，扩展为与boxes相同的形状
  354.             scale_tensor = torch.FloatTensor([[scale, 1, scale, 1]]).expand_as(boxes)
  355.             # 将尺度因子应用到中心点信息boxes上，进行尺度变换
  356.             boxes = boxes * scale_tensor
  357.             # 返回尺度变换后的图像和边界框
  358.             return bgr, boxes
  359.             # 如果不进行尺度变换，则返回原图像和边界框
  360.         return bgr, boxes
  361.  
  362.         # 定义randomCrop方法，用于对图像进行随机裁剪
  363.  
  364.     # 随机裁剪图片和边界框
  365.     def randomCrop(self, bgr, boxes, labels):
  366.         # 如果随机生成的小于0.5的数，则执行随机裁剪
  367.         if random.random() < 0.5:
  368.             # 计算边界框的中心点
  369.             center = (boxes[:, 2:] + boxes[:, :2]) / 2
  370.             # 获取图像的高度、宽度和通道数
  371.             height, width, c = bgr.shape
  372.             # 生成随机裁剪的高度和宽度，至少为原图像的60%
  373.             h = random.uniform(0.6 * height, height)
  374.             w = random.uniform(0.6 * width, width)
  375.             # 生成随机裁剪的起始坐标
  376.             x = random.uniform(0, width - w)
  377.             y = random.uniform(0, height - h)
  378.             # 将坐标和裁剪的尺寸转换为整数
  379.             x, y, h, w = int(x), int(y), int(h), int(w)
  380.  
  381.             # 将裁剪起始坐标转换为Tensor，并从中心点中减去
  382.             center = center - torch.FloatTensor([[x, y]]).expand_as(center)
  383.             # 创建掩码，筛选出中心点落在裁剪区域内的边界框
  384.             mask1 = (center[:, 0] > 0) & (center[:, 0] < w)
  385.             mask2 = (center[:, 1] > 0) & (center[:, 1] < h)
  386.             # 将两个掩码合并，并展平为一维Tensor
  387.             mask = (mask1 & mask2).view(-1, 1)
  388.  
  389.             # 根据掩码筛选出裁剪区域内的边界框
  390.             boxes_in = boxes[mask.expand_as(boxes)].view(-1, 4)
  391.             # 如果没有边界框落在裁剪区域内，则返回原图像、原边界框和原标签
  392.             if (len(boxes_in) == 0):
  393.                 return bgr, boxes, labels
  394.                 # 创建一个Tensor，用于存储裁剪起始坐标，扩展为与boxes_in相同的形状
  395.             box_shift = torch.FloatTensor([[x, y, x, y]]).expand_as(boxes_in)
  396.  
  397.             # 将裁剪起始坐标从边界框中减去
  398.             boxes_in = boxes_in - box_shift
  399.             # 确保裁剪后的边界框坐标在裁剪区域内
  400.             boxes_in[:, 0] = boxes_in[:, 0].clamp_(min=0, max=w)
  401.             boxes_in[:, 2] = boxes_in[:, 2].clamp_(min=0, max=w)
  402.             boxes_in[:, 1] = boxes_in[:, 1].clamp_(min=0, max=h)
  403.             boxes_in[:, 3] = boxes_in[:, 3].clamp_(min=0, max=h)
  404.  
  405.             # 根据掩码筛选出裁剪区域内的标签
  406.             labels_in = labels[mask.view(-1)]
  407.             # 裁剪图像
  408.             img_croped = bgr[y:y + h, x:x + w, :]
  409.             # 返回裁剪后的图像、裁剪区域内的边界框和标签
  410.             return img_croped, boxes_in, labels_in
  411.             # 如果不进行裁剪，则返回原图像、原边界框和原标签
  412.         return bgr, boxes, labels
  413.  
  414.  
  415.     # 定义subMean方法，用于从图像中减去均值
  416.     def subMean(self, bgr, mean):
  417.         # 将均值转换为float32类型的numpy数组
  418.         mean = np.array(mean, dtype=np.float32)
  419.         # 从图像bgr中减去均值
  420.         bgr = bgr - mean
  421.         # 返回减去均值后的图像
  422.         return bgr
  423.  
  424.         # 定义random_flip方法，用于随机对图像进行水平翻转，并相应地更新边界框
  425.  
  426.     # 随机翻转图片和边界框
  427.     def random_flip(self, im, boxes):
  428.         # 以0.5的概率决定是否进行翻转
  429.         if random.random() < 0.5:
  430.             # 对图像进行水平翻转
  431.             im_lr = np.fliplr(im).copy()
  432.             # 获取图像的高度、宽度
  433.             h, w, _ = im.shape
  434.             # 更新边界框的左边界为原右边界与图像宽度的差值
  435.             xmin = w - boxes[:, 2]
  436.             # 更新边界框的右边界为原左边界与图像宽度的差值
  437.             xmax = w - boxes[:, 0]
  438.             # 将更新后的左右边界赋值回边界框
  439.             boxes[:, 0] = xmin
  440.             boxes[:, 2] = xmax
  441.             # 返回翻转后的图像和更新后的边界框
  442.             return im_lr, boxes
  443.         # 如果不进行翻转，则返回原图像和原边界框
  444.         return im, boxes
  445.  
  446.     # 定义random_bright方法，用于随机调整图像的亮度
  447.     def random_bright(self, im, delta=16):
  448.         # 生成一个0到1之间的随机数
  449.         alpha = random.random()
  450.         # 如果该随机数大于0.3
  451.         if alpha > 0.3:
  452.             # 调整图像的亮度，乘以随机数alpha并加上一个-delta到delta之间的随机整数
  453.             im = im * alpha + random.randrange(-delta, delta)
  454.             # 将调整亮度后的图像像素值限制在0到255之间，并转换为uint8类型
  455.             im = im.clip(min=0, max=255).astype(np.uint8)
  456.             # 返回调整亮度后的图像
  457.         return im
  458.  
  459.  
  460. # 3. 调试代码
  461. def main():
  462.     from torch.utils.data import DataLoader
  463.     import torchvision.transforms as transforms
  464.     file_root = '../data/VOC2012/JPEGImages/' # 记得改为自己的路径
  465.     train_dataset = Yolo_Dataset(root=file_root,list_file='voctrain.txt',train=True,transforms = [T.ToTensor()] )
  466.     train_loader = DataLoader(train_dataset,batch_size=1,shuffle=False,num_workers=0)
  467.     train_iter = iter(train_loader)
  468.     for i in range(100):
  469.         img,target = next(train_iter)
  470.         print(img.shape)
  471.         print(target.shape)
  472.         break
  473.  
  474. if __name__ == '__main__':
  475.     main()

1.5、定义主函数

       在utils目录下创建工具类 yolo_dataset.py，中定义主函数进行测试，包含设置和加载一个自定义的Yolo_Dataset数据集，该数据集来源于VOC2012的JPEGImages文件夹。代码中首先导入了必要的模块和类，然后定义了数据集的根目录和预处理操作。接着，创建了一个Yolo_Dataset对象，并通过DataLoader类将其加载为可迭代的数据集。DataLoader的参数包括数据集、批次大小、是否打乱数据以及使用的子进程数量。最后，通过迭代器遍历数据集，获取图像和对应的目标数据，并打印它们的维度信息。

  1. # 3. 调试代码
  2. # 定义一个名为main的函数
  3. def main():
  4.     # 从torch.utils.data模块中导入DataLoader类，用于加载数据集
  5.     from torch.utils.data import DataLoader
  6.  
  7.     # 导入torchvision.transforms模块，用于图像预处理
  8.     import torchvision.transforms as transforms
  9.  
  10.     # 设置文件根目录路径，这里假设是VOC2012数据集的JPEGImages文件夹
  11.     file_root = '../data/VOC2012/JPEGImages/'  # 记得改为自己的路径
  12.  
  13.     # 创建一个Yolo_Dataset对象，该对象可能是自定义的，用于加载VOC2012数据集
  14.     # 参数包括：
  15.     # root: 数据集的根目录
  16.     # list_file: 包含训练图像文件名的列表文件
  17.     # train: 是否为训练模式
  18.     # transforms: 图像预处理操作列表，这里只有一个操作，即将图像转换为Tensor
  19.     train_dataset = Yolo_Dataset(root=file_root, list_file='voctrain.txt', train=True,
  20.                                  transforms=[transforms.ToTensor()])
  21.  
  22.     # 使用DataLoader类加载训练数据集
  23.     # 参数包括：
  24.     # dataset: 要加载的数据集
  25.     # batch_size: 每个批次的大小
  26.     # shuffle: 是否在每个epoch开始时打乱数据
  27.     # num_workers: 加载数据使用的子进程数量
  28.     train_loader = DataLoader(train_dataset, batch_size=1, shuffle=False, num_workers=0)
  29.  
  30.     # 创建一个迭代器，用于遍历train_loader中的数据
  31.     train_iter = iter(train_loader)
  32.  
  33.     # 遍历前100个批次的数据（但由于下面的break语句，实际上只会处理一个批次）
  34.     for i in range(100):
  35.         # 使用迭代器获取下一个批次的数据，包括图像和目标（可能是标签或边界框）
  36.         img, target = next(train_iter)
  37.  
  38.         # 打印图像的shape（维度）
  39.         print(img.shape)
  40.  
  41.         # 打印目标的shape（维度）
  42.         print(target.shape)
  43.  
  44.         # 跳出循环，因此只处理一个批次的数据
  45.         break
  46.  
  47. if __name__ == '__main__':
  48.     main()

2构建网络

       在YOLO（You Only Look Once）系列的目标检测算法中，Backbone是一个核心组成部分，主要负责提取输入图像的特征。具体来说，Backbone是一种卷积神经网络，它通过多层次的特征提取，从低层次到高层次逐渐提取出图像的不同特征，如边缘、纹理、形状等，最终生成一个高维度的特征向量。这些特征向量在后续的网络层中被用于目标检测和分类等任务。

       在YOLOv1中，大部分人都选用的ResNet作为自己的backbone，因为可以方便调用官方的预训练权重。

2.1 ResNet架构介绍

      ResNet架构使用残差的模式，即输出值为F(x)+x模式，简单理解就是至少不比上次结果差。不了解可以参考其他人博客.

2.2 构建ResNet

       在创建的目录结构network中创建Yolo_ResNet.py文件，用于创建 Base_Block、Senior_Block、Output_Block 和 ResNet。

      ResNet是一个基于残差块（Block）的卷积神经网络结构。它使用多个层级，每个层级包含多个残差块(Block)。构建残差块时候需要注意的是，ResNet18—ResNet152共有两种类型的Block块，一种不涉及1*1卷积网络，另外一种涉及1*1卷积网络，如下图所示：

       自己实现Block时候也要有涉及1*1卷积网络 和 不涉及1*1卷积网络 两种方式。

2.2.1 构建Base_Block

       Base_Block类是一个神经网络的基础块，它定义了一个具有残差连接的结构，这在深度神经网络中（如ResNet）是非常常见的。这个类中不包含 1*1 的卷积，以下是该类中几个函数的主要作用：

__init__ 函数
  • 作用：初始化Base_Block对象。
  • 功能：
    • 接收输入通道数（in_planes）、输出通道数（out_planes）、步长（stride）以及下采样函数（downsample）作为参数。
    • 定义并初始化两个卷积层（conv1 和 conv2）、两个批量归一化层（bn1 和 bn2）以及ReLU激活函数（relu）。其中，conv1 和 conv2  使用 3x3 的卷积核。
    • 保存传入的下采样函数（downsample）和步长（stride）以便后续使用。
forward 函数
  • 作用：定义网络块的前向传播过程。
  • 功能：
    • 接收输入数据x。
    • 保留输入x作为残差（res），用于后续与卷积处理后的输出相加。
    • 将输入x通过两个卷积层、两个批量归一化层以及ReLU激活函数。
    • 如果提供了下采样函数，则对残差res进行下采样，使其维度与卷积后的输出一致。
    • 将卷积处理后的输出与残差res相加，实现残差连接。
    • 对相加后的结果再次应用ReLU激活函数。
    • 返回前向传播的结果。
  1. '''
  2. # 2. 构建block: 不含有1*1
  3. # 定义一个基础块类，继承自nn.Module，用于构建神经网络的基础结构  
  4. '''
  5. class Base_Block(nn.Module):
  6.     # 用于扩充的变量，表示扩大几倍
  7.     # 在某些网络结构中，如ResNet的Bottleneck块，可能需要通过该变量来扩充通道数
  8.     expansion = 1
  9.  
  10.     def __init__(self, in_planes, out_planes, stride=1, downsample=None):
  11.         # 初始化函数，传入输入通道数、输出通道数、步长以及下采样函数
  12.         '''
  13.         :param in_planes: 输入的通道数
  14.         :param planes: 输出的通道数
  15.         :param stride: 默认步长
  16.         :param downsample: 是否进行下采样
  17.         '''
  18.  
  19.         # 调用父类nn.Module的初始化函数
  20.         super(Base_Block, self).__init__()
  21.  
  22.         # 定义网络结构 + 初始化参数
  23.         # 第一个卷积层
  24.         self.conv1 = nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride, padding=1, bias=False)
  25.         # 第一个批量归一化层
  26.         self.bn1 = nn.BatchNorm2d(out_planes)
  27.         # ReLU激活函数，inplace=True表示直接改变原始参数值，节省内存
  28.         self.relu = nn.ReLU(inplace=True)
  29.         # 第二个卷积层
  30.         self.conv2 = nn.Conv2d(out_planes, out_planes, kernel_size=3, stride=1, padding=1, bias=False)
  31.         # 第二个批量归一化层
  32.         self.bn2 = nn.BatchNorm2d(out_planes)
  33.         # 下采样函数，用于调整输入x的维度，以便与卷积后的输出维度一致
  34.         self.downsample = downsample
  35.         # 存储步长，以便后续可能用到
  36.         self.stride = stride
  37.  
  38.     # 定义前向传播函数
  39.     def forward(self, x):
  40.         # 残差，即直接输入x，后续会与卷积处理后的输出相加
  41.         res = x
  42.  
  43.         # 正常传播
  44.         # 通过第一个卷积层
  45.         out = self.conv1(x)
  46.         # 通过第一个批量归一化层
  47.         out = self.bn1(out)
  48.         # 通过ReLU激活函数
  49.         out = self.relu(out)
  50.         # 通过第二个卷积层
  51.         out = self.conv2(out)
  52.         # 通过第二个批量归一化层
  53.         out = self.bn2(out)
  54.  
  55.         # 判断是否下采样
  56.         # 如果需要下采样，则调整残差res的维度
  57.         if self.downsample is not None:
  58.             res = self.downsample(res)
  59.  
  60.         # 残差相加
  61.         # 将残差res与卷积处理后的输出out相加，实现残差连接
  62.         out += res
  63.  
  64.         # 再次通过ReLU激活函数
  65.         out = self.relu(out)
  66.  
  67.         # 返回结果
  68.         return out

2.2.2 构建Senior_Block

        Senior_Block 类是用于构建更复杂的网络结构。类中包含1*1卷积核3*3卷积，下面是该类中几个函数的主要作用：

__init__ 初始化函数
  • 作用：初始化 Senior_Block 对象，设置网络层的结构和参数。
  • 功能：
    • 接收输入通道数（in_planes）、中间通道数（planes）、步长（stride）以及下采样方法（downsample）作为参数。
    • 定义三个卷积层（conv1、conv2、conv3）和对应的批量归一化层（bn1、bn2、bn3）。其中，conv1 和 conv3 使用 1x1 的卷积核，conv2 使用 3x3 的卷积核。
    • 定义 ReLU 激活函数（relu）。
    • 保存传入的下采样方法（downsample）和步长（stride）以便后续使用。
forward 前向传播函数
  • 作用：定义网络块的前向传播过程，即数据从输入到输出的计算流程。
  • 功能：
    • 接收输入数据 x。
    • 保留输入 x 作为残差（res），用于后续与卷积处理后的输出相加。
    • 将输入 x 通过三个卷积层（conv1、conv2、conv3）和对应的批量归一化层（bn1、bn2、bn3），以及 ReLU 激活函数。
    • 如果提供了下采样方法，则对残差 res 进行下采样，使其维度与卷积后的输出一致。
    • 将卷积处理后的输出与残差 res 相加，实现残差连接。
    • 对相加后的结果再次应用 ReLU 激活函数。
    • 返回前向传播的结果。
  1. '''
  2. # 3. 构建Block：含有1*1
  3. # 定义高级块类，继承自nn.Module，用于构建更复杂的网络结构 
  4. '''
  5. class Senior_Block(nn.Module):
  6.     expansion = 4
  7.  
  8.     def __init__(self, in_planes, planes, stride=1, downsample=None):
  9.         '''
  10.         :param in_planes: 输入通道数
  11.         :param planes: 中间通道数，最终的输出通道数还需要乘以扩大系数，即expansion
  12.         :param stride: 步长
  13.         :param downsample: 下采样方法
  14.         '''
  15.         super(Senior_Block, self).__init__()
  16.         self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=1, bias=False)
  17.         self.bn1 = nn.BatchNorm2d(planes)
  18.         self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
  19.         self.bn2 = nn.BatchNorm2d(planes)
  20.         self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)
  21.         self.bn3 = nn.BatchNorm2d(planes * 4)
  22.         self.relu = nn.ReLU(inplace=True)
  23.         self.downsample = downsample
  24.         self.stride = stride
  25.  
  26.     def forward(self, x):
  27.         # 残差
  28.         res = x
  29.         # 前向传播
  30.         out = self.conv1(x)
  31.         out = self.bn1(out)
  32.         out = self.relu(out)
  33.         out = self.conv2(out)
  34.         out = self.bn2(out)
  35.         out = self.relu(out)
  36.         out = self.conv3(out)
  37.         out = self.bn3(out)
  38.         # 是否下采样
  39.         if self.downsample is not None:
  40.             res = self.downsample(x)
  41.         # 相加
  42.         out += res
  43.         out = self.relu(out)
  44.         return out

2.2.3 构建Output_Block

       Output_Block 类是用于构建神经网络的一部分。下面是该类中几个函数的主要作用：

__init__ 初始化函数
  • 作用：初始化 Output_Block 对象，设置网络层的结构和参数。
  • 功能：
    • 接收输入通道数（in_planes）、中间通道数（planes）、步长（stride）以及块类型（block_type）作为参数。
    • 定义三个卷积层（conv1、conv2、conv3）和对应的批量归一化层（bn1、bn2、bn3）。其中，conv1 和 conv3 使用 1x1 的卷积核，conv2 使用 3x3 的卷积核。。
    • 根据步长、输入通道数和块类型，判断是否需要进行下采样，并初始化下采样层（downsample）。
forward 前向传播函数
  • 作用：定义网络块的前向传播过程，即数据从输入到输出的计算流程。
  • 功能：
    • 接收输入数据 x。
    • 将输入 x 通过三个卷积层（conv1、conv2、conv3）和对应的批量归一化层（bn1、bn2、bn3），并在每个卷积层之后应用 ReLU 激活函数。
    • 将输入 x 通过下采样层（downsample），以便与卷积处理后的输出 out 的维度相匹配。
    • 将卷积处理后的输出 out 与下采样后的输入相加，实现残差连接。
    • 返回前向传播的结果。

  1. '''
  2. # 4. 构建输出层
  3. # 定义输出块类，继承自nn.Module，用于构建更复杂的网络结构 
  4. '''
  5. class Output_Block(nn.Module):
  6.     # 定义扩大系数，该块最终输出的通道数将与中间通道数相同
  7.     expansion = 1
  8.     def __init__(self, in_planes, planes, stride=1, block_type='A'):
  9.         # 初始化函数，传入输入通道数、中间通道数、步长以及块类型
  10.         '''
  11.         :param in_planes: 输入通道数
  12.         :param planes: 中间通道数
  13.         :param stride: 步长
  14.         :param block_type: 块类型，为'A'表示不需要下采样，为'B'则需要
  15.         '''
  16.  
  17.         # 调用父类nn.Module的初始化函数
  18.         super(Output_Block, self).__init__()
  19.  
  20.         # 定义第一个卷积层，用于改变通道数
  21.         self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=1, bias=False)
  22.  
  23.         # 定义第一个批量归一化层
  24.         self.bn1 = nn.BatchNorm2d(planes)
  25.  
  26.         # 定义第二个卷积层，使用3x3的卷积核，带有2的空洞率（dilation），可以增大感受野
  27.         self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, padding=2, bias=False, dilation=2)
  28.  
  29.         # 定义第二个批量归一化层
  30.         self.bn2 = nn.BatchNorm2d(planes)
  31.  
  32.         # 定义第三个卷积层，用于调整通道数至最终的输出通道数
  33.         self.conv3 = nn.Conv2d(planes, self.expansion * planes, kernel_size=1, bias=False)
  34.  
  35.         # 定义第三个批量归一化层
  36.         self.bn3 = nn.BatchNorm2d(self.expansion * planes)
  37.  
  38.         # 初始化下采样层，默认是一个空的序列
  39.         self.downsample = nn.Sequential()
  40.  
  41.         # 判断是否需要下采样，这里综合了步长、通道数以及块类型
  42.         if stride != 1 or in_planes != self.expansion * planes or block_type == 'B':
  43.             # 如果需要下采样，则设置下采样层
  44.             self.downsample = nn.Sequential(
  45.                 # 定义一个卷积层，用于调整输入的通道数和维度
  46.                 nn.Conv2d(in_planes, self.expansion * planes, kernel_size=1, stride=stride, bias=False),
  47.                 # 定义一个批量归一化层
  48.                 nn.BatchNorm2d(self.expansion * planes)
  49.             )
  50.  
  51.     # 定义前向传播函数
  52.     def forward(self, x):
  53.         # 通过第一个卷积层和批量归一化层，并应用ReLU激活函数
  54.         out = F.relu(self.bn1(self.conv1(x)))
  55.  
  56.         # 通过第二个卷积层和批量归一化层，并再次应用ReLU激活函数
  57.         out = F.relu(self.bn2(self.conv2(out)))
  58.  
  59.         # 通过第三个卷积层和批量归一化层
  60.         out = self.bn3(self.conv3(out))
  61.  
  62.         # 将输入x通过下采样层，以便与out的维度相匹配
  63.         # 如果不需要下采样，则下采样层是一个空操作
  64.         out += self.downsample(x)
  65.  
  66.         # 应用ReLU激活函数
  67.         out = F.relu(out)
  68.  
  69.         # 返回输出结果
  70.         return out

2.2.4 构建ResNet

   ResNet类定义了一个基于残差块（block）的卷积神经网络结构。它使用了多个层级（layer1至layer4）和一个输出层（layer5），以及一个平均池化层和一个最终的卷积层。下面是该类中几个函数的主要作用：

__init__ 初始化函数
  • 作用：初始化ResNet对象，设置网络的结构和参数。
  • 功能：
    • 设置初始通道数self.inplanes为64。
    • 定义初始卷积层self.conv1，用于从输入图像中提取特征。
    • 定义批标准化层self.bn1和ReLU激活函数self.relu，用于处理conv1的输出。
    • 定义最大池化层self.maxpool，用于进一步减小特征图的尺寸。
    • 使用_make_layer方法创建四个层级（layer1至layer4），每个层级包含多个残差块。
    • 使用_make_out_layer方法创建输出层self.layer5。
    • 定义平均池化层self.avgpool，用于减小特征图的尺寸。
    • 定义最终的卷积层self.conv_end和批标准化层self.bn_end，用于输出层的处理。
    • 初始化模型参数，使用正态分布初始化卷积层的权重，并将批标准化层的权重初始化为1，偏置初始化为0。
_make_layer 方法
  • 作用：根据输入的block类型、输出通道数、block数量和步长，创建并返回一个层级（layer）。
  • 功能：
    • 循环创建指定数量的block对象，并将它们添加到一个nn.Sequential容器中。
    • 在第一个block中，根据步长设置是否进行下采样。
    • 返回包含多个block的层级。
_make_out_layer 方法
  • 作用：创建输出层。
  • 功能：
    • 根据输入的通道数，定义输出层的结构。
    • 输出层的具体结构在代码中没有给出，但通常会包含卷积层、批标准化层等。
forward 方法
  • 作用：定义网络的前向传播过程，即从输入到输出的计算流程。
  • 功能：
    • 接收输入数据，并通过初始卷积层、批标准化层、ReLU激活函数和最大池化层进行处理。
    • 将处理后的数据依次通过四个层级（layer1至layer4）和输出层（layer5）。
    • 通过平均池化层减小特征图的尺寸。
    • 通过最终的卷积层和批标准化层进行处理，得到网络的输出。
初始化模型参数部分
  • 作用：对模型中的参数进行初始化。
  • 功能：
    • 遍历模型中的所有模块。
    • 对于卷积层，使用正态分布初始化权重，标准差根据卷积核的大小和输出通道数计算得出。
    • 对于批标准化层，将权重初始化为1，偏置初始化为0。
  1. '''
  2. # 5. 构建ResNet
  3. # 定义ResNet类，继承自nn.Module，用于构建更复杂的网络结构 
  4. '''
  5. class ResNet(nn.Module):
  6.  
  7.     def __init__(self, block, layers):
  8.         '''
  9.         初始化ResNet网络。
  10.         :param block: 基本的Block块对象，如BasicBlock或Bottleneck。
  11.         :param layers: 不同层级的block数量，例如ResNet50为[3, 4, 6, 3]。
  12.         '''
  13.         super(ResNet, self).__init__()  # 调用父类nn.Module的初始化方法。
  14.  
  15.         # 初始通道数设置为64
  16.         self.inplanes = 64
  17.  
  18.         # 初始卷积层，输入通道为3（RGB图像），输出通道为64，卷积核大小为7x7，步长为2，填充为3，无偏置。
  19.         self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
  20.  
  21.         # 批标准化层，用于conv1的输出
  22.         self.bn1 = nn.BatchNorm2d(64)
  23.  
  24.         # ReLU激活函数，inplace=True表示直接在原变量上进行操作，节省内存。
  25.         self.relu = nn.ReLU(inplace=True)
  26.  
  27.         # 最大池化层，池化核大小为3x3，步长为2，填充为1。
  28.         self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
  29.  
  30.         # 根据输入的block和layers创建不同的层级
  31.         # 创建四个层级（layer1至layer4），每个层级包含多个残差块
  32.         self.layer1 = self._make_layer(block, 64, layers[0])  # 第一层，输出通道为64，block数量由layers[0]决定。
  33.         self.layer2 = self._make_layer(block, 128, layers[1], stride=2)  # 第二层，输出通道为128，block数量由layers[1]决定，步长为2。
  34.         self.layer3 = self._make_layer(block, 256, layers[2], stride=2)  # 第三层，输出通道为256，block数量由layers[2]决定，步长为2。
  35.         self.layer4 = self._make_layer(block, 512, layers[3], stride=2)  # 第四层，输出通道为512，block数量由layers[3]决定，步长为2。
  36.  
  37.         # 创建输出层
  38.         self.layer5 = self._make_out_layer(in_channels=2048)  # 输出层的输入通道为2048。
  39.  
  40.         # 平均池化层，池化核大小和步长均为2。
  41.         self.avgpool = nn.AvgPool2d(2)
  42.  
  43.         # 最后的卷积层，将输出通道变为30，卷积核大小为3x3，步长为1，填充为1，无偏置。
  44.         self.conv_end = nn.Conv2d(256, 30, kernel_size=3, stride=1, padding=1, bias=False)
  45.  
  46.         # 批标准化层，用于conv_end的输出
  47.         self.bn_end = nn.BatchNorm2d(30)
  48.  
  49.         # 初始化模型参数
  50.         for m in self.modules():  # 遍历模型中的所有模块
  51.             if isinstance(m, nn.Conv2d):  # 如果是卷积层
  52.                 n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels  # 计算权重初始化的标准差
  53.                 m.weight.data.normal_(0, math.sqrt(2. / n))  # 使用正态分布初始化权重
  54.             elif isinstance(m, nn.BatchNorm2d):  # 如果是批标准化层
  55.                 m.weight.data.fill_(1)  # 权重初始化为1
  56.                 m.bias.data.zero_()  # 偏置初始化为0
  57.         # 根据传入的layer个数和block创建
  58.  
  59.     # 输入层的构建
  60.     def _make_layer(self, block, planes, blocks, stride=1):
  61.         '''
  62.         根据给定的block类型、输出通道数、block数量和步长来创建一系列block组成的层。
  63.         :param block: 要使用的block类型，是一个类，如BasicBlock或Bottleneck
  64.         :param planes: 每个block的输出通道数
  65.         :param blocks: 需要搭建的block数量
  66.         :param stride: 第一个block的卷积层步长，用于控制是否进行下采样
  67.         '''
  68.  
  69.         # 初始化下采样变量，用于第一个block可能需要的下采样操作
  70.         downsample = None
  71.  
  72.         # 判断是否需要进行下采样
  73.         # 如果步长不为1，或者当前层的输入通道数（self.inplanes）与block输出通道数（planes * block.expansion）不匹配，则进行下采样
  74.         if stride != 1 or self.inplanes != planes * block.expansion:
  75.             downsample = nn.Sequential(
  76.                 # 使用1x1的卷积层进行通道数转换和步长调整，使得残差连接可以相加
  77.                 nn.Conv2d(self.inplanes, planes * block.expansion, kernel_size=1, stride=stride, bias=False),
  78.                 # 批量归一化，稳定训练过程
  79.                 nn.BatchNorm2d(planes * block.expansion),
  80.             )
  81.  
  82.         # 初始化层的列表
  83.         layers = []
  84.  
  85.         # 添加第一个block，并可能进行下采样
  86.         # 第一个block的输入通道数是self.inplanes，输出通道数是planes，步长是stride，可能包含下采样操作
  87.         layers.append(block(self.inplanes, planes, stride, downsample))
  88.  
  89.         # 更新当前层的输入通道数为block的输出通道数
  90.         self.inplanes = planes * block.expansion
  91.  
  92.         # 添加剩余的blocks，它们的输入通道数已经是更新后的self.inplanes，输出通道数保持不变
  93.         for i in range(1, blocks):
  94.             layers.append(block(self.inplanes, planes))
  95.  
  96.             # 将层的列表转换为Sequential模型，便于作为神经网络的一部分进行前向传播
  97.         return nn.Sequential(*layers)  # *操作符用于将列表中的元素解包为函数参数
  98.  
  99.     # 输出层的构建
  100.     def _make_out_layer(self, in_channels):
  101.         '''
  102.         根据输入通道数构建输出层，包含多个Output_Block。
  103.         :param in_channels: 输入通道数
  104.         '''
  105.  
  106.         # 初始化层的列表
  107.         layers = []
  108.  
  109.         # 添加第一个Output_Block，并指定其输入通道数和输出通道数
  110.         # 注意：这里使用了block_type参数来区分不同的Output_Block类型
  111.         layers.append(Output_Block(in_planes=in_channels, planes=256, block_type='B'))
  112.  
  113.         # 添加两个相同类型的Output_Block，输入通道数和输出通道数都保持不变
  114.         layers.append(Output_Block(in_planes=256, planes=256, block_type='A'))
  115.         layers.append(Output_Block(in_planes=256, planes=256, block_type='A'))
  116.  
  117.         # 将层的列表转换为Sequential模型
  118.         return nn.Sequential(*layers)  # *操作符用于将列表中的元素解包为函数参数
  119.  
  120.     def forward(self, x):
  121.         # x 为网络的输入，这里的前向传播方法描述了网络如何从输入x获得最终的输出
  122.  
  123.         # 经历共有的卷积和池化层
  124.         # 第一个卷积层，对输入x进行卷积操作
  125.         x = self.conv1(x)
  126.         # 批量归一化层，对卷积后的结果进行归一化处理
  127.         x = self.bn1(x)
  128.         # ReLU激活函数，对归一化后的结果进行非线性变换
  129.         x = self.relu(x)
  130.         # 最大池化层，对激活后的结果进行下采样
  131.         x = self.maxpool(x)
  132.  
  133.         # 经历各个block块
  134.         # 第一个block层，对池化后的结果进行进一步的特征提取
  135.         x = self.layer1(x)
  136.         # 第二个block层，继续提取特征
  137.         x = self.layer2(x)
  138.         # 第三个block层
  139.         x = self.layer3(x)
  140.         # 第四个block层
  141.         x = self.layer4(x)
  142.         # 第五个block层，这里需要注意，通常标准的ResNet结构中只有4个layer，这里可能是自定义的扩展
  143.         x = self.layer5(x)
  144.  
  145.         # 经历最终的输出
  146.         # 平均池化层，对最后一个block的输出进行全局平均池化
  147.         x = self.avgpool(x)
  148.         # 卷积层，对池化后的结果进行进一步的卷积变换
  149.         x = self.conv_end(x)
  150.         # 批量归一化层，对卷积后的结果进行归一化处理
  151.         x = self.bn_end(x)
  152.         # Sigmoid激活函数，将特征映射到0-1之间
  153.         x = F.sigmoid(x)  # 归一化到0-1
  154.  
  155.         # 将输出构建为正确的shape
  156.         # permute函数用于改变张量的维度顺序，这里将通道维度移动到最后一个位置
  157.         # 假设输出shape原本为(-1, C, H, W)，经过permute后变为(-1, H, W, C)
  158.         x = x.permute(0, 2, 3, 1)  # (-1,7,7,30)
  159.  
  160.         # 返回最终的输出x
  161.         return x

2.3 定义模型

      构建不同的ResNet函数。即不同的ResNet模型。如下：

  1. # 6. 构建不同的ResNet函数
  2. # 预训练下载链接
  3. model_urls = {
  4.     'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
  5.     'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
  6.     'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
  7.     'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',
  8.     'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth',
  9. }
  10.  
  11.  
  12. # 构建ResNet18
  13. def resnet18(pretrained=False, **kwargs):
  14.     model = ResNet(Base_Block, [2, 2, 2, 2], **kwargs)
  15.     # 是否预训练
  16.     if pretrained:
  17.         model.load_state_dict(model_zoo.load_url(model_urls['resnet18']))
  18.     return model
  19.  
  20.  
  21. # 构建ResNet34
  22. def resnet34(pretrained=False, **kwargs):
  23.     model = ResNet(Base_Block, [3, 4, 6, 3], **kwargs)
  24.     if pretrained:
  25.         model.load_state_dict(model_zoo.load_url(model_urls['resnet34']))
  26.     return model
  27.  
  28.  
  29. # 构建ResNet50
  30. def resnet50(pretrained=False, **kwargs):
  31.     model = ResNet(Senior_Block, [3, 4, 6, 3], **kwargs)
  32.     if pretrained:
  33.         model.load_state_dict(model_zoo.load_url(model_urls['resnet50']))
  34.     return model
  35.  
  36.  
  37. # 构建ResNet101
  38. def resnet101(pretrained=False, **kwargs):
  39.     model = ResNet(Senior_Block, [3, 4, 23, 3], **kwargs)
  40.     if pretrained:
  41.         model.load_state_dict(model_zoo.load_url(model_urls['resnet101']))
  42.     return model
  43.  
  44.  
  45. # 构建ResNet152
  46. def resnet152(pretrained=False, **kwargs):
  47.     model = ResNet(Senior_Block, [3, 8, 36, 3], **kwargs)
  48.     if pretrained:
  49.         model.load_state_dict(model_zoo.load_url(model_urls['resnet152']))
  50.     return model

2.4 完整代码

Yolo_ResNet卷积神经网络

  1. ''
  2. '''
  3. # 1. 导入所需要的包
  4. '''
  5. import torch
  6. import math
  7. from torch import nn
  8. import torch.utils.model_zoo as model_zoo
  9. import torch.nn.functional as F
  10.  
  11. '''
  12. # 2. 构建block: 不含有1*1
  13. # 定义一个基础块类，继承自nn.Module，用于构建神经网络的基础结构  
  14. '''
  15. class Base_Block(nn.Module):
  16.     # 用于扩充的变量，表示扩大几倍
  17.     # 在某些网络结构中，如ResNet的Bottleneck块，可能需要通过该变量来扩充通道数
  18.     expansion = 1
  19.  
  20.     def __init__(self, in_planes, out_planes, stride=1, downsample=None):
  21.         # 初始化函数，传入输入通道数、输出通道数、步长以及下采样函数
  22.         '''
  23.         :param in_planes: 输入的通道数
  24.         :param planes: 输出的通道数
  25.         :param stride: 默认步长
  26.         :param downsample: 是否进行下采样
  27.         '''
  28.  
  29.         # 调用父类nn.Module的初始化函数
  30.         super(Base_Block, self).__init__()
  31.  
  32.         # 定义网络结构 + 初始化参数
  33.         # 第一个卷积层
  34.         self.conv1 = nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride, padding=1, bias=False)
  35.         # 第一个批量归一化层
  36.         self.bn1 = nn.BatchNorm2d(out_planes)
  37.         # ReLU激活函数，inplace=True表示直接改变原始参数值，节省内存
  38.         self.relu = nn.ReLU(inplace=True)
  39.         # 第二个卷积层
  40.         self.conv2 = nn.Conv2d(out_planes, out_planes, kernel_size=3, stride=1, padding=1, bias=False)
  41.         # 第二个批量归一化层
  42.         self.bn2 = nn.BatchNorm2d(out_planes)
  43.         # 下采样函数，用于调整输入x的维度，以便与卷积后的输出维度一致
  44.         self.downsample = downsample
  45.         # 存储步长，以便后续可能用到
  46.         self.stride = stride
  47.  
  48.     # 定义前向传播函数
  49.     def forward(self, x):
  50.         # 残差，即直接输入x，后续会与卷积处理后的输出相加
  51.         res = x
  52.  
  53.         # 正常传播
  54.         # 通过第一个卷积层
  55.         out = self.conv1(x)
  56.         # 通过第一个批量归一化层
  57.         out = self.bn1(out)
  58.         # 通过ReLU激活函数
  59.         out = self.relu(out)
  60.         # 通过第二个卷积层
  61.         out = self.conv2(out)
  62.         # 通过第二个批量归一化层
  63.         out = self.bn2(out)
  64.  
  65.         # 判断是否下采样
  66.         # 如果需要下采样，则调整残差res的维度
  67.         if self.downsample is not None:
  68.             res = self.downsample(res)
  69.  
  70.         # 残差相加
  71.         # 将残差res与卷积处理后的输出out相加，实现残差连接
  72.         out += res
  73.  
  74.         # 再次通过ReLU激活函数
  75.         out = self.relu(out)
  76.  
  77.         # 返回结果
  78.         return out
  79.  
  80. '''
  81. # 3. 构建Block：含有1*1
  82. # 定义高级块类，继承自nn.Module，用于构建更复杂的网络结构 
  83. '''
  84. class Senior_Block(nn.Module):
  85.     expansion = 4
  86.  
  87.     def __init__(self, in_planes, planes, stride=1, downsample=None):
  88.         '''
  89.         :param in_planes: 输入通道数
  90.         :param planes: 中间通道数，最终的输出通道数还需要乘以扩大系数，即expansion
  91.         :param stride: 步长
  92.         :param downsample: 下采样方法
  93.         '''
  94.         super(Senior_Block, self).__init__()
  95.         self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=1, bias=False)
  96.         self.bn1 = nn.BatchNorm2d(planes)
  97.         self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
  98.         self.bn2 = nn.BatchNorm2d(planes)
  99.         self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)
  100.         self.bn3 = nn.BatchNorm2d(planes * 4)
  101.         self.relu = nn.ReLU(inplace=True)
  102.         self.downsample = downsample
  103.         self.stride = stride
  104.  
  105.     def forward(self, x):
  106.         # 残差
  107.         res = x
  108.         # 前向传播
  109.         out = self.conv1(x)
  110.         out = self.bn1(out)
  111.         out = self.relu(out)
  112.         out = self.conv2(out)
  113.         out = self.bn2(out)
  114.         out = self.relu(out)
  115.         out = self.conv3(out)
  116.         out = self.bn3(out)
  117.         # 是否下采样
  118.         if self.downsample is not None:
  119.             res = self.downsample(x)
  120.         # 相加
  121.         out += res
  122.         out = self.relu(out)
  123.         return out
  124.  
  125.  
  126.  
  127. '''
  128. # 4. 构建输出层
  129. # 定义输出块类，继承自nn.Module，用于构建更复杂的网络结构 
  130. '''
  131. class Output_Block(nn.Module):
  132.     # 定义扩大系数，该块最终输出的通道数将与中间通道数相同
  133.     expansion = 1
  134.     def __init__(self, in_planes, planes, stride=1, block_type='A'):
  135.         # 初始化函数，传入输入通道数、中间通道数、步长以及块类型
  136.         '''
  137.         :param in_planes: 输入通道数
  138.         :param planes: 中间通道数
  139.         :param stride: 步长
  140.         :param block_type: 块类型，为'A'表示不需要下采样，为'B'则需要
  141.         '''
  142.  
  143.         # 调用父类nn.Module的初始化函数
  144.         super(Output_Block, self).__init__()
  145.  
  146.         # 定义第一个卷积层，用于改变通道数
  147.         self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=1, bias=False)
  148.  
  149.         # 定义第一个批量归一化层
  150.         self.bn1 = nn.BatchNorm2d(planes)
  151.  
  152.         # 定义第二个卷积层，使用3x3的卷积核，带有2的空洞率（dilation），可以增大感受野
  153.         self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, padding=2, bias=False, dilation=2)
  154.  
  155.         # 定义第二个批量归一化层
  156.         self.bn2 = nn.BatchNorm2d(planes)
  157.  
  158.         # 定义第三个卷积层，用于调整通道数至最终的输出通道数
  159.         self.conv3 = nn.Conv2d(planes, self.expansion * planes, kernel_size=1, bias=False)
  160.  
  161.         # 定义第三个批量归一化层
  162.         self.bn3 = nn.BatchNorm2d(self.expansion * planes)
  163.  
  164.         # 初始化下采样层，默认是一个空的序列
  165.         self.downsample = nn.Sequential()
  166.  
  167.         # 判断是否需要下采样，这里综合了步长、通道数以及块类型
  168.         if stride != 1 or in_planes != self.expansion * planes or block_type == 'B':
  169.             # 如果需要下采样，则设置下采样层
  170.             self.downsample = nn.Sequential(
  171.                 # 定义一个卷积层，用于调整输入的通道数和维度
  172.                 nn.Conv2d(in_planes, self.expansion * planes, kernel_size=1, stride=stride, bias=False),
  173.                 # 定义一个批量归一化层
  174.                 nn.BatchNorm2d(self.expansion * planes)
  175.             )
  176.  
  177.     # 定义前向传播函数
  178.     def forward(self, x):
  179.         # 通过第一个卷积层和批量归一化层，并应用ReLU激活函数
  180.         out = F.relu(self.bn1(self.conv1(x)))
  181.  
  182.         # 通过第二个卷积层和批量归一化层，并再次应用ReLU激活函数
  183.         out = F.relu(self.bn2(self.conv2(out)))
  184.  
  185.         # 通过第三个卷积层和批量归一化层
  186.         out = self.bn3(self.conv3(out))
  187.  
  188.         # 将输入x通过下采样层，以便与out的维度相匹配
  189.         # 如果不需要下采样，则下采样层是一个空操作
  190.         out += self.downsample(x)
  191.  
  192.         # 应用ReLU激活函数
  193.         out = F.relu(out)
  194.  
  195.         # 返回输出结果
  196.         return out
  197.  
  198.  
  199.  
  200. '''
  201. # 5. 构建ResNet
  202. # 定义ResNet类，继承自nn.Module，用于构建更复杂的网络结构 
  203. '''
  204. class ResNet(nn.Module):
  205.  
  206.     def __init__(self, block, layers):
  207.         '''
  208.         初始化ResNet网络。
  209.         :param block: 基本的Block块对象，如BasicBlock或Bottleneck。
  210.         :param layers: 不同层级的block数量，例如ResNet50为[3, 4, 6, 3]。
  211.         '''
  212.         super(ResNet, self).__init__()  # 调用父类nn.Module的初始化方法。
  213.  
  214.         # 初始通道数设置为64
  215.         self.inplanes = 64
  216.  
  217.         # 初始卷积层，输入通道为3（RGB图像），输出通道为64，卷积核大小为7x7，步长为2，填充为3，无偏置。
  218.         self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
  219.  
  220.         # 批标准化层，用于conv1的输出
  221.         self.bn1 = nn.BatchNorm2d(64)
  222.  
  223.         # ReLU激活函数，inplace=True表示直接在原变量上进行操作，节省内存。
  224.         self.relu = nn.ReLU(inplace=True)
  225.  
  226.         # 最大池化层，池化核大小为3x3，步长为2，填充为1。
  227.         self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
  228.  
  229.         # 根据输入的block和layers创建不同的层级
  230.         # 创建四个层级（layer1至layer4），每个层级包含多个残差块
  231.         self.layer1 = self._make_layer(block, 64, layers[0])  # 第一层，输出通道为64，block数量由layers[0]决定。
  232.         self.layer2 = self._make_layer(block, 128, layers[1], stride=2)  # 第二层，输出通道为128，block数量由layers[1]决定，步长为2。
  233.         self.layer3 = self._make_layer(block, 256, layers[2], stride=2)  # 第三层，输出通道为256，block数量由layers[2]决定，步长为2。
  234.         self.layer4 = self._make_layer(block, 512, layers[3], stride=2)  # 第四层，输出通道为512，block数量由layers[3]决定，步长为2。
  235.  
  236.         # 创建输出层
  237.         self.layer5 = self._make_out_layer(in_channels=2048)  # 输出层的输入通道为2048。
  238.  
  239.         # 平均池化层，池化核大小和步长均为2。
  240.         self.avgpool = nn.AvgPool2d(2)
  241.  
  242.         # 最后的卷积层，将输出通道变为30，卷积核大小为3x3，步长为1，填充为1，无偏置。
  243.         self.conv_end = nn.Conv2d(256, 30, kernel_size=3, stride=1, padding=1, bias=False)
  244.  
  245.         # 批标准化层，用于conv_end的输出
  246.         self.bn_end = nn.BatchNorm2d(30)
  247.  
  248.         # 初始化模型参数
  249.         for m in self.modules():  # 遍历模型中的所有模块
  250.             if isinstance(m, nn.Conv2d):  # 如果是卷积层
  251.                 n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels  # 计算权重初始化的标准差
  252.                 m.weight.data.normal_(0, math.sqrt(2. / n))  # 使用正态分布初始化权重
  253.             elif isinstance(m, nn.BatchNorm2d):  # 如果是批标准化层
  254.                 m.weight.data.fill_(1)  # 权重初始化为1
  255.                 m.bias.data.zero_()  # 偏置初始化为0
  256.         # 根据传入的layer个数和block创建
  257.  
  258.     # 输入层的构建
  259.     def _make_layer(self, block, planes, blocks, stride=1):
  260.         '''
  261.         根据给定的block类型、输出通道数、block数量和步长来创建一系列block组成的层。
  262.         :param block: 要使用的block类型，是一个类，如BasicBlock或Bottleneck
  263.         :param planes: 每个block的输出通道数
  264.         :param blocks: 需要搭建的block数量
  265.         :param stride: 第一个block的卷积层步长，用于控制是否进行下采样
  266.         '''
  267.  
  268.         # 初始化下采样变量，用于第一个block可能需要的下采样操作
  269.         downsample = None
  270.  
  271.         # 判断是否需要进行下采样
  272.         # 如果步长不为1，或者当前层的输入通道数（self.inplanes）与block输出通道数（planes * block.expansion）不匹配，则进行下采样
  273.         if stride != 1 or self.inplanes != planes * block.expansion:
  274.             downsample = nn.Sequential(
  275.                 # 使用1x1的卷积层进行通道数转换和步长调整，使得残差连接可以相加
  276.                 nn.Conv2d(self.inplanes, planes * block.expansion, kernel_size=1, stride=stride, bias=False),
  277.                 # 批量归一化，稳定训练过程
  278.                 nn.BatchNorm2d(planes * block.expansion),
  279.             )
  280.  
  281.         # 初始化层的列表
  282.         layers = []
  283.  
  284.         # 添加第一个block，并可能进行下采样
  285.         # 第一个block的输入通道数是self.inplanes，输出通道数是planes，步长是stride，可能包含下采样操作
  286.         layers.append(block(self.inplanes, planes, stride, downsample))
  287.  
  288.         # 更新当前层的输入通道数为block的输出通道数
  289.         self.inplanes = planes * block.expansion
  290.  
  291.         # 添加剩余的blocks，它们的输入通道数已经是更新后的self.inplanes，输出通道数保持不变
  292.         for i in range(1, blocks):
  293.             layers.append(block(self.inplanes, planes))
  294.  
  295.             # 将层的列表转换为Sequential模型，便于作为神经网络的一部分进行前向传播
  296.         return nn.Sequential(*layers)  # *操作符用于将列表中的元素解包为函数参数
  297.  
  298.     # 输出层的构建
  299.     def _make_out_layer(self, in_channels):
  300.         '''
  301.         根据输入通道数构建输出层，包含多个Output_Block。
  302.         :param in_channels: 输入通道数
  303.         '''
  304.  
  305.         # 初始化层的列表
  306.         layers = []
  307.  
  308.         # 添加第一个Output_Block，并指定其输入通道数和输出通道数
  309.         # 注意：这里使用了block_type参数来区分不同的Output_Block类型
  310.         layers.append(Output_Block(in_planes=in_channels, planes=256, block_type='B'))
  311.  
  312.         # 添加两个相同类型的Output_Block，输入通道数和输出通道数都保持不变
  313.         layers.append(Output_Block(in_planes=256, planes=256, block_type='A'))
  314.         layers.append(Output_Block(in_planes=256, planes=256, block_type='A'))
  315.  
  316.         # 将层的列表转换为Sequential模型
  317.         return nn.Sequential(*layers)  # *操作符用于将列表中的元素解包为函数参数
  318.  
  319.     def forward(self, x):
  320.         # x 为网络的输入，这里的前向传播方法描述了网络如何从输入x获得最终的输出
  321.  
  322.         # 经历共有的卷积和池化层
  323.         # 第一个卷积层，对输入x进行卷积操作
  324.         x = self.conv1(x)
  325.         # 批量归一化层，对卷积后的结果进行归一化处理
  326.         x = self.bn1(x)
  327.         # ReLU激活函数，对归一化后的结果进行非线性变换
  328.         x = self.relu(x)
  329.         # 最大池化层，对激活后的结果进行下采样
  330.         x = self.maxpool(x)
  331.  
  332.         # 经历各个block块
  333.         # 第一个block层，对池化后的结果进行进一步的特征提取
  334.         x = self.layer1(x)
  335.         # 第二个block层，继续提取特征
  336.         x = self.layer2(x)
  337.         # 第三个block层
  338.         x = self.layer3(x)
  339.         # 第四个block层
  340.         x = self.layer4(x)
  341.         # 第五个block层，这里需要注意，通常标准的ResNet结构中只有4个layer，这里可能是自定义的扩展
  342.         x = self.layer5(x)
  343.  
  344.         # 经历最终的输出
  345.         # 平均池化层，对最后一个block的输出进行全局平均池化
  346.         x = self.avgpool(x)
  347.         # 卷积层，对池化后的结果进行进一步的卷积变换
  348.         x = self.conv_end(x)
  349.         # 批量归一化层，对卷积后的结果进行归一化处理
  350.         x = self.bn_end(x)
  351.         # Sigmoid激活函数，将特征映射到0-1之间
  352.         x = F.sigmoid(x)  # 归一化到0-1
  353.  
  354.         # 将输出构建为正确的shape
  355.         # permute函数用于改变张量的维度顺序，这里将通道维度移动到最后一个位置
  356.         # 假设输出shape原本为(-1, C, H, W)，经过permute后变为(-1, H, W, C)
  357.         x = x.permute(0, 2, 3, 1)  # (-1,7,7,30)
  358.  
  359.         # 返回最终的输出x
  360.         return x
  361.  
  362.  
  363. # 6. 构建不同的ResNet函数
  364. # 预训练下载链接
  365. model_urls = {
  366.     'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
  367.     'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
  368.     'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
  369.     'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',
  370.     'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth',
  371. }
  372.  
  373.  
  374. # 构建ResNet18
  375. def resnet18(pretrained=False, **kwargs):
  376.     model = ResNet(Base_Block, [2, 2, 2, 2], **kwargs)
  377.     # 是否预训练
  378.     if pretrained:
  379.         model.load_state_dict(model_zoo.load_url(model_urls['resnet18']))
  380.     return model
  381.  
  382.  
  383. # 构建ResNet34
  384. def resnet34(pretrained=False, **kwargs):
  385.     model = ResNet(Base_Block, [3, 4, 6, 3], **kwargs)
  386.     if pretrained:
  387.         model.load_state_dict(model_zoo.load_url(model_urls['resnet34']))
  388.     return model
  389.  
  390.  
  391. # 构建ResNet50
  392. def resnet50(pretrained=False, **kwargs):
  393.     model = ResNet(Senior_Block, [3, 4, 6, 3], **kwargs)
  394.     if pretrained:
  395.         model.load_state_dict(model_zoo.load_url(model_urls['resnet50']))
  396.     return model
  397.  
  398.  
  399. # 构建ResNet101
  400. def resnet101(pretrained=False, **kwargs):
  401.     model = ResNet(Senior_Block, [3, 4, 23, 3], **kwargs)
  402.     if pretrained:
  403.         model.load_state_dict(model_zoo.load_url(model_urls['resnet101']))
  404.     return model
  405.  
  406.  
  407. # 构建ResNet152
  408. def resnet152(pretrained=False, **kwargs):
  409.     model = ResNet(Senior_Block, [3, 8, 36, 3], **kwargs)
  410.     if pretrained:
  411.         model.load_state_dict(model_zoo.load_url(model_urls['resnet152']))
  412.     return model

 3、定义损失

       在创建的目录结构 network 中创建Yolo_Loss.py文件，用于创建损失。

       YOLO的损失函数通常包括以下几个部分：

  1. 定位损失（Localization Loss）：即长宽损失和坐标损失，用于衡量模型预测的目标边界框与真实边界框之间的差异。这通常使用均方误差（MSE）或其他类似的回归损失函数来计算。定位损失关注于边界框的中心点坐标（x, y）、宽度（w）和高度（h）的预测精度。
  2. 置信度损失（Confidence Loss）：用于衡量模型预测的目标置信度与真实置信度之间的差异。置信度表示模型对预测目标存在的信心程度。对于每个边界框，模型会预测一个置信度分数，这个分数与真实标签（目标存在与否）进行比较，计算损失。
  3. 分类损失（Classification Loss）：用于衡量模型预测的目标类别与真实类别之间的差异。这通常使用交叉熵损失函数来计算。对于每个目标，模型会预测一个类别概率分布，这个分布与真实标签进行比较，计算损失。

      在YOLO的损失函数中，这些部分通常会根据它们的重要性进行加权。例如，由于定位的准确性对于目标检测至关重要，因此定位损失通常会赋予较高的权重。而置信度损失和分类损失的权重则可以根据具体任务进行调整。

       此外，YOLO的损失函数还需要考虑如何处理没有目标的背景区域。这通常通过在损失函数中加入一个额外的项来实现，该项用于惩罚模型在背景区域产生高置信度的预测。

总的来说，YOLO的损失函数是一个综合了定位、置信度和分类损失的复合函数，旨在全面地衡量模型在目标检测任务上的性能。通过优化这个损失函数，我们可以训练出更加准确和鲁棒的目标检测模型。

  1.  
  2. # 1. 导包
  3. import torch
  4. import torch.nn as nn
  5. import torch.nn.functional as F
  6. from torch.autograd import Variable
  7.  
  8.  
  9. # 2. 损失函数类
  10. class Yolo_Loss(nn.Module):
  11.     def __init__(self, S=7, B=2, l_coord=5, l_noobj=0.5):
  12.         '''
  13.         :param S: Yolov1论文中的S，即划分的网格，默认为7
  14.         :param B: Yolov1论文中的B，即多少个框预测，默认为2
  15.         :param l_coord:  损失函数中的超参数，默认为5
  16.         :param l_noobj:  同上，默认为0.5
  17.         '''
  18.         super(Yolo_Loss, self).__init__()
  19.         # 初始化各个参数
  20.         self.S = S
  21.         self.B = B
  22.         self.l_coord = l_coord
  23.         self.l_noobj = l_noobj
  24.  
  25.     # 前向传播
  26.     def forward(self, pred_tensor, target_tensor):
  27.         # 获取batchsize大小 ,即每批次数据的个数
  28.         N = pred_tensor.size()[0]
  29.  
  30.         # target_tensor[:, :, :, 4]是目标张量中用于标记 目标 是否存在的部分（通常第五列是置信度或目标存在标志）。
  31.         # 这行代码生成一个布尔掩码，其中值为True的位置表示对应网格中存在目标，值为False则表示不存在。
  32.         # 具有目标标签的索引值，此时shape为[batch,7,7]
  33.         coo_mask = target_tensor[:, :, :, 4] > 0
  34.  
  35.         # 与上一行相反，这行代码生成一个布尔掩码，表示哪些网格中没有目标。
  36.         # 不具有目标的标签索引值，此时shape为[batch,7,7]
  37.         noo_mask = target_tensor[:, :, :, 4] == 0
  38.  
  39.         # unsqueeze(-1)在最后一个维度上增加一个维度，使得coo_mask的形状从[batch, 7, 7]变为[batch, 7, 7, 1]。
  40.         # expand_as(target_tensor)将这个新维度扩展至与target_tensor相同的形状，这样便于后续操作。
  41.         # 将shape变为[batch,7,7,30]
  42.         coo_mask = coo_mask.unsqueeze(-1).expand_as(target_tensor)
  43.  
  44.         # 同上，对noo_mask也进行相同的操作。
  45.         noo_mask = noo_mask.unsqueeze(-1).expand_as(target_tensor)
  46.  
  47.         # 使用coo_mask从pred_tensor中索引出存在目标的预测值，然后通过view操作改变形状，使得每个存在目标的预测框成为一个长度为30的向量。
  48.         # 获取预测值中包含对象的所有点（共7*7个点），并转为[x,30]的形式，其中x表示有多少点中的框包含有对象
  49.         coo_pred = pred_tensor[coo_mask].view(-1, 30)
  50.  
  51.         # 对上面获取的值进行处理
  52.         # 从coo_pred中取前10个元素（对应预测框的坐标和宽度高度信息），然后改变形状为[2x, 5]，其中x表示存在目标的网格数量。
  53.         # 1. 转为box形式：box[x1,y1,w1,h1,c1]，shape为[2x,5]，因为每个单元格/点有两个预测框
  54.         box_pred = coo_pred[:, :10].contiguous().view(-1, 5)
  55.  
  56.         # 从coo_pred中取后20个元素（对应类别预测信息）。
  57.         # 2. 转为class信息，即30中后面的20个值
  58.         class_pred = coo_pred[:, 10:]
  59.  
  60.         # 对目标张量进行与预测张量相同的操作，获取存在目标的真实值。
  61.         # 同理，对真实值进行操作，方便对比计算损失值
  62.         coo_target = target_tensor[coo_mask].view(-1, 30)
  63.  
  64.         # 从coo_target中取出坐标和宽度高度信息。
  65.         box_target = coo_target[:, :10].contiguous().view(-1, 5)
  66.  
  67.         # 从coo_target中取出类别信息。
  68.         class_target = coo_target[:, 10:]
  69.  
  70.         # 同上的操作，获取不包含对象的预测值、真实值
  71.         # 使用noo_mask从pred_tensor中索引出不存在目标的预测值，并改变形状。
  72.         noo_pred = pred_tensor[noo_mask].view(-1, 30)
  73.  
  74.         # 对目标张量执行相同的操作，获取不存在目标的真实值。
  75.         noo_target = target_tensor[noo_mask].view(-1, 30)
  76.  
  77.         # 注意：上述代码只是将预测值和真实值进行了预处理，以便后续计算损失。实际损失的计算（比如坐标损失、置信度损失和类别损失）在这段代码之后，通常还需要根据YOLO的具体定义来编写。
  78.  
  79.         # 不包含物体grid ceil的置信度损失：即图中的D部分
  80.         # 这部分代码计算的是那些不包含目标物体的网格中预测框的置信度损失。
  81.         # 1. 自己创建一个索引
  82.         # 创建一个与noo_pred形状相同的全零的ByteTensor（布尔掩码），用于标识需要计算的预测框置信度。
  83.         noo_pred_mask = torch.cuda.ByteTensor(noo_pred.size())
  84.  
  85.         # 将这个掩码的所有元素初始化为0（即False），意味着初始时所有预测框的置信度都不被考虑。
  86.         noo_pred_mask.zero_()  # 将全部元素变为Flase的意思
  87.  
  88.         # 2. 将其它位置的索引置为0，唯独两个框的置信度位置变为1
  89.         # 将所有网格中第一个预测框的置信度位置（索引为4，因为通常置信度是预测框向量的最后一个元素，且前面有4个坐标值）设置为1。
  90.         noo_pred_mask[:, 4] = 1
  91.         # 将所有网格中第二个预测框的置信度位置（索引为9，因为每个网格有两个预测框，每个预测框有5个值：4个坐标和1个置信度）设置为1。
  92.         noo_pred_mask[:, 9] = 1
  93.  
  94.         # 3. 获取对应的值
  95.         # 使用上面创建的掩码从noo_pred中提取出所有预测框的置信度值。
  96.         noo_pred_c = noo_pred[noo_pred_mask]  # noo pred只需要计算 c 的损失 size[-1,2]
  97.         # 同样地，使用相同的掩码从noo_target中提取出目标置信度值，用于与预测值比较。
  98.         noo_target_c = noo_target[noo_pred_mask]
  99.  
  100.         # 4. 计算损失值：均方误差
  101.         # 使用均方误差（Mean Squared Error, MSE）计算预测置信度与目标置信度之间的差异，作为不包含物体网格的置信度损失。
  102.         nooobj_loss = F.mse_loss(noo_pred_c, noo_target_c, size_average=False)
  103.  
  104.         # 计算包含物体的损失值
  105.         # 创建几个全为False/0的变量，用于后期存储值
  106.         # 创建一个与box_target形状相同的全零的ByteTensor，用于标识负责预测物体的网格中的预测框。
  107.         coo_response_mask = torch.cuda.ByteTensor(box_target.size())  # 负责预测框
  108.  
  109.         # 将这个掩码的所有元素初始化为0。
  110.         coo_response_mask.zero_()
  111.  
  112.         # 创建一个与box_target形状相同的全零的ByteTensor，用于标识不负责预测物体的网格中的预测框。
  113.         coo_not_response_mask = torch.cuda.ByteTensor(box_target.size())  # 不负责预测的框的索引（因为一个cell两个预测框，而只有IOU最大的负责索引）
  114.  
  115.         # 将这个掩码的所有元素初始化为0。
  116.         coo_not_response_mask.zero_()
  117.  
  118.         # 创建一个与box_target形状相同的全零的Tensor，用于存放每个预测框与目标框之间的IOU（交并比）值。这个值在后续计算损失时会用到。
  119.         box_target_iou = torch.zeros(box_target.size()).cuda()  # 具体的IOU值存放处
  120.  
  121.         # 由于一个单元格两个预测框，因此step=2
  122.         # 在YOLO系列算法中，每个网格单元通常预测固定数量的预测框。这里假设每个单元有两个预测框，因此迭代步长为2。
  123.         # 遍历所有目标框，因为每个目标框与一个单元格关联，且每个单元格有两个预测框。
  124.         # 选择具有最佳IOU的预测框。
  125.         for i in range(0, box_target.size()[0], 2):  # choose the best iou box
  126.  
  127.             # 获取预测值中的两个box
  128.             # 从预测框集合中取出当前单元格的两个预测框。这里box1是一个包含两个预测框的tensor，每个预测框有五个值：[x, y, w, h, c]，分别代表中心坐标、宽度、高度和置信度。
  129.             box1 = box_pred[i:i + 2]  # [x,y,w,h,c]
  130.  
  131.             # 创建一个临时变量box1形状相同的tensor，用于存放左上角和右下角角坐标值，因为计算IOU需要
  132.             box1_xyxy = Variable(torch.FloatTensor(box1.size()))
  133.  
  134.             # 将预测框的中心坐标和宽高转换为左上角和右下角的坐标，并进行归一化处理。self.S通常表示网格的大小，比如7x7的网格。
  135.             box1_xyxy[:, :2] = box1[:, :2] / float(self.S) - 0.5 * box1[:, 2:4]  # 原本(xc,yc)为7*7 所以要除以7
  136.  
  137.             # 同样地，计算预测框的右下角坐标。
  138.             box1_xyxy[:, 2:4] = box1[:, :2] / float(self.S) + 0.5 * box1[:, 2:4]
  139.  
  140.             # 用同样的思路对真实值进行处理，不过不同的是真实值一个对象只有一个框
  141.             # 从目标框集合中取出与当前单元格关联的目标框，并将其reshape为[-1, 5]的形式。
  142.             box2 = box_target[i].view(-1, 5)
  143.  
  144.             # 创建一个与目标框形状相同的tensor，用于存放左上角和右下角坐标形式的目标框。
  145.             box2_xyxy = Variable(torch.FloatTensor(box2.size()))
  146.  
  147.             # 将目标框的中心坐标和宽高转换为左上角和右下角的坐标，并进行归一化处理。
  148.             box2_xyxy[:, :2] = box2[:, :2] / float(self.S) - 0.5 * box2[:, 2:4]
  149.  
  150.             # 计算目标框的右下角坐标。
  151.             box2_xyxy[:, 2:4] = box2[:, :2] / float(self.S) + 0.5 * box2[:, 2:4]
  152.  
  153.             # 计算两者的IOU
  154.             # 调用compute_iou函数计算两个预测框与目标框之间的IOU值。这里box1_xyxy[:, :4]包含两个预测框的坐标，box2_xyxy[:, :4]包含一个目标框的坐标。
  155.             iou = self.compute_iou(box1_xyxy[:, :4], box2_xyxy[:, :4])  # 前者shape为[2,4]，后者为[1,4]
  156.  
  157.             # 获取两者IOU最大的值（max_iou）和对应的索引（max_index），因为一个cell有两个预测框，一般而言取IOU最大的作为预测框
  158.             max_iou, max_index = iou.max(0)
  159.  
  160.             # 将索引移至GPU上（如果之前不在GPU上的话）。
  161.             max_index = max_index.data.cuda()
  162.  
  163.             # 将IOU最大的索引设置为1，即表示这个框负责预测
  164.             coo_response_mask[i + max_index] = 1
  165.  
  166.         # 将box_target_iou转为PyTorch的Variable，并移到GPU上（如果有的话），以支持自动微分。
  167.         box_target_iou = Variable(box_target_iou).cuda()
  168.  
  169.         # 获取负责预测框的值、IOU值和真实框的值
  170.         # 从box_pred中筛选出负责预测的框（即IOU最大的框），并改变其形状为[-1, 5]。
  171.         box_pred_response = box_pred[coo_response_mask].view(-1, 5)
  172.  
  173.         # 从box_target_iou中筛选出负责预测的框的IOU值，并改变其形状。
  174.         box_target_response_iou = box_target_iou[coo_response_mask].view(-1, 5)
  175.  
  176.         # 从box_target中筛选出负责预测的框的真实值，并改变其形状。
  177.         box_target_response = box_target[coo_response_mask].view(-1, 5)
  178.  
  179.         # 这个对应的是图中的部分C，负责预测框的损失
  180.         # 计算负责预测框的置信度损失，使用均方误差损失函数（MSE Loss）。
  181.         contain_loss = F.mse_loss(box_pred_response[:, 4], box_target_response_iou[:, 4], size_average=False)
  182.  
  183.         # 1. 计算坐标损失，即图中的A和B部分
  184.         # 计算负责预测框的坐标损失，包括中心坐标和宽高的损失。注意，宽高损失计算时使用了开方，这通常是为了改善损失函数的性能。
  185.         loc_loss = F.mse_loss(box_pred_response[:, :2], box_target_response[:, :2], size_average=False) + F.mse_loss(
  186.             torch.sqrt(box_pred_response[:, 2:4]), torch.sqrt(box_target_response[:, 2:4]), size_average=False)
  187.  
  188.         # 获取不负责预测框的值、真实值
  189.         # 从box_pred中筛选出不负责预测的框，并改变其形状。
  190.         box_pred_not_response = box_pred[coo_not_response_mask].view(-1, 5)
  191.  
  192.         # 从box_target中筛选出不负责预测的框的真实值，并改变其形状。
  193.         box_target_not_response = box_target[coo_not_response_mask].view(-1, 5)
  194.  
  195.         # 将不负责预测框的置信度真实值设为0，因为这些框不应包含任何对象。
  196.         box_target_not_response[:, 4] = 0  # 将真实值置为0
  197.  
  198.         # 2. 计算不负责预测框的损失值，即图中的部分C
  199.         # 计算不负责预测框的置信度损失。
  200.         not_contain_loss = F.mse_loss(box_pred_not_response[:, 4], box_target_not_response[:, 4], size_average=False)
  201.  
  202.         # 3. 类别损失，即图中的E部分
  203.         # 计算类别损失，使用均方误差损失函数。
  204.         class_loss = F.mse_loss(class_pred, class_target, size_average=False)
  205.  
  206.         # 返回总损失，它是坐标损失、负责预测框的置信度损失、不负责预测框的置信度损失、类别损失以及一个未显示的`nooobj_loss`的加权和，最后除以N进行归一化。
  207.         return (self.l_coord * loc_loss + contain_loss + not_contain_loss + self.l_noobj * nooobj_loss + class_loss) / N
  208.  
  209.     # 计算IOU的函数
  210.     def compute_iou(self, box1, box2):
  211.         '''
  212.         :param box1: 预测的box，一般为[2,4]
  213.         :param box2: 真实的box，一般为[1,4]
  214.         :return:
  215.         '''
  216.         # 获取各box个数
  217.         N = box1.size(0)
  218.         M = box2.size(0)
  219.         # 计算两者中左上角左边较大的
  220.         lt = torch.max(
  221.             box1[:, :2].unsqueeze(1).expand(N, M, 2),  # [N,2] -> [N,1,2] -> [N,M,2]
  222.             box2[:, :2].unsqueeze(0).expand(N, M, 2),  # [M,2] -> [1,M,2] -> [N,M,2]
  223.         )
  224.         # 计算两者右下角左边较小的
  225.         rb = torch.min(
  226.             box1[:, 2:].unsqueeze(1).expand(N, M, 2),  # [N,2] -> [N,1,2] -> [N,M,2]
  227.             box2[:, 2:].unsqueeze(0).expand(N, M, 2),  # [M,2] -> [1,M,2] -> [N,M,2]
  228.         )
  229.         # 计算两者相交部分的长、宽
  230.         wh = rb - lt  # [N,M,2]
  231.         # 如果长、宽中有小于0的，表示可能没有相交趋于，置为0即可
  232.         wh[wh < 0] = 0  # clip at 0
  233.         inter = wh[:, :, 0] * wh[:, :, 1]  # [N,M]
  234.  
  235.         # 计算各个的面积
  236.         # box1的面积
  237.         area1 = (box1[:, 2] - box1[:, 0]) * (box1[:, 3] - box1[:, 1])  # [N,]
  238.         # box2的面积
  239.         area2 = (box2[:, 2] - box2[:, 0]) * (box2[:, 3] - box2[:, 1])  # [M,]
  240.         area1 = area1.unsqueeze(1).expand_as(inter)  # [N,] -> [N,1] -> [N,M]
  241.         area2 = area2.unsqueeze(0).expand_as(inter)  # [M,] -> [1,M] -> [N,M]
  242.         # IOu值，交集除以并集，其中并集为两者的面积和减去交集部分
  243.         iou = inter / (area1 + area2 - inter)
  244.         return iou

4、定义训练过程

      在创建的目录结构 network 中创建train.py文件，用于进行训练。

  1. 导入所需的包
  2. 定义基本参数
  3. 创建模型并使用预训练参数
  4. 损失函数，优化器，并将模型、损失函数放入GPU中
  5. 加载数据
  6. 训练：循环50次，第20和第35次调整学习率，每次对数据集中按批次执行训练和验证
  1. # 1. 导入所需的包
  2. import warnings
  3.  
  4. from YOLOv1.network.Yolo_ResNet import resnet50
  5. from YOLOv1.utils.yolo_dataset import Yolo_Dataset
  6. from YOLOv1_pytorch.utils.Yolo_Loss import Yolo_Loss
  7.  
  8. warnings.filterwarnings("ignore")
  9. from tqdm import tqdm
  10. import torch
  11. from torch.utils.data import DataLoader
  12. import torchvision.transforms as T
  13. from torchvision import models
  14.  
  15.  
  16. # 2. 定义基本参数
  17. device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
  18. batch_size = 2      # 根据自己的电脑设定
  19. epochs = 50
  20. lr = 0.01
  21. file_root = './data/VOC2012/JPEGImages/'   # 需要根据的实际路径修改
  22.  
  23. # 3. 创建模型并使用预训练参数
  24. pytorch_resnet = models.resnet50(pretrained=True)   # 官方的resnet50预训练模型
  25. model = resnet50()   # 创建自己的resnet50，
  26.  
  27. # 接下来就是让自己的模型去继承官方的权重参数
  28. pytorch_state_dict = pytorch_resnet.state_dict()
  29. model_state_dict = model.state_dict()
  30.  
  31. for k in pytorch_state_dict.keys():
  32.     # 调试: 看看模型哪些有没有问题
  33.     # print(k)
  34.     # 如果自己的模型和官方的模型key相同，并且不是fc层，则继承过来
  35.     if k in model_state_dict.keys() and not k.startswith('fc'):
  36.         model_state_dict[k] = pytorch_state_dict[k]
  37.  
  38. # 4. 损失函数，优化器，并将模型、损失函数放入GPU中
  39. loss = Yolo_Loss()
  40. optimizer = torch.optim.SGD(model.parameters(),lr=lr,momentum=0.9,weight_decay=5e-4)
  41. model.to(device)
  42. loss.to(device)
  43.  
  44. # 5. 加载数据
  45. train_dataset = Yolo_Dataset(root=file_root, list_file='./utils/voctrain.txt', train=True, transforms = [T.ToTensor()])
  46. train_loader = DataLoader(train_dataset,batch_size=batch_size,shuffle=True,drop_last=True)
  47. test_dataset = Yolo_Dataset(root=file_root, list_file='./utils/voctest.txt', train=False, transforms = [T.ToTensor()])
  48. test_loader = DataLoader(test_dataset,batch_size=batch_size,shuffle=True,drop_last=True)
  49.  
  50. # 6. 训练
  51. # 打印一些基本的信息
  52. print('starting train the model')
  53. print('the train_dataset has %d images' % len(train_dataset))
  54. print('the batch_size is ',batch_size)
  55. # 定义一个最佳损失值
  56. best_test_loss = 0
  57. # 开始训练
  58. for e in range(epochs):
  59.     model.train()
  60.     # 调整学习率
  61.     if e == 20:
  62.         print('change the lr')
  63.         optimizer.param_groups[0]['lr'] /= 10
  64.     if e == 35:
  65.         print('change the lr')
  66.         optimizer.param_groups[0]['lr'] /= 10
  67.     # 进度条显示
  68.     tqdm_tarin = tqdm(train_loader)
  69.     # 定义损失变量
  70.     total_loss = 0.
  71.     for i,(images,target) in enumerate(tqdm_tarin):
  72.         # 将变量放入设备中
  73.         images,target = images.to(device),target.to(device)
  74.         # 训练--损失等
  75.         pred = model(images)
  76.         loss_value = loss(pred,target)
  77.         total_loss += loss_value.item()
  78.         #在开始新的梯度计算之前，调用优化器的zero_grad()方法将模型参数的梯度清零。这是因为在PyTorch中，梯度是累积的，如果不清零，新的梯度会累加到旧的梯度上。
  79.         optimizer.zero_grad()
  80.         #对损失值loss_value调用backward()方法，计算损失相对于模型参数的梯度。这些梯度将被用于接下来的参数更新步骤。
  81.         loss_value.backward()
  82.         #调用优化器的step()方法，根据计算出的梯度更新模型的参数。这一步是模型训练的关键，它使得模型在训练过程中逐渐优化。
  83.         optimizer.step()
  84.         # 打印一下损失值
  85.         if (i+1) % 5 == 0:
  86.             tqdm_tarin.desc = 'train epoch[{}/{}] loss:{:.6f}'.format(e+1,epochs,total_loss/(i+1))
  87.     # 启用验证模式
  88.     model.eval()
  89.     validation_loss = 0.0
  90.     tqdm_test = tqdm(test_loader)
  91.     for i, (images, target) in enumerate(tqdm_test):
  92.         images, target = images.to(device),target.to(device)
  93.         pred = model(images)
  94.         loss_value = loss(pred, target)
  95.         validation_loss += loss_value.item()
  96.     validation_loss /= len(test_loader)
  97.     # 显示验证集的损失值
  98.     print('In the test step,the average loss is %.6f' % validation_loss)
  99.     # 如果最佳损失值大于验证集的损失，意味着当前训练很好
  100.     # 这一点需要设置好最佳的损失值，不容易设置
  101.     # 是否启用看大家心情
  102.     # if best_test_loss > validation_loss:
  103.     #     best_test_loss = validation_loss
  104.     #     print('get best test loss %.5f' % best_test_loss)
  105.     #     torch.save(model.state_dict(), './weights/best.pth')
  106.     # 记得最后保存参数
  107.     torch.save(model.state_dict(), './weights/yolo.pth')

5、定义预测方法

       在创建的目录结构 network 中创建predict.py文件，用于进行预测。同时在目录test_images中存入预测的图片（在最下面，自己进行保存，并进行命名为1、2、3、4、5、6）

  1. # author: baiCai
  2. # 1. 导包
  3. import os
  4. import random
  5. import torch
  6. from torch.autograd import Variable
  7. import torchvision.transforms as transforms
  8. import cv2
  9. from matplotlib import pyplot as plt
  10. import numpy as np
  11. import warnings
  12.  
  13. from YOLOv1_pytorch.network.My_ResNet import resnet50
  14.  
  15. warnings.filterwarnings('ignore')
  16.  
  17.  
  18.  
  19. # 2. 定义一些基本的参数
  20. # 类别索引
  21. VOC_CLASSES = (
  22.     'aeroplane', 'bicycle', 'bird', 'boat',
  23.     'bottle', 'bus', 'car', 'cat', 'chair',
  24.     'cow', 'diningtable', 'dog', 'horse',
  25.     'motorbike', 'person', 'pottedplant',
  26. 'sheep', 'sofa', 'train', 'tvmonitor')
  27. # 画矩形框的时候用到的颜色变量
  28. Color = [[0, 0, 0],
  29.                     [128, 0, 0],
  30.                     [0, 128, 0],
  31.                     [128, 128, 0],
  32.                     [0, 0, 128],
  33.                     [128, 0, 128],
  34.                     [0, 128, 128],
  35.                     [128, 128, 128],
  36.                     [64, 0, 0],
  37.                     [192, 0, 0],
  38.                     [64, 128, 0],
  39.                     [192, 128, 0],
  40.                     [64, 0, 128],
  41.                     [192, 0, 128],
  42.                     [64, 128, 128],
  43.                     [192, 128, 128],
  44.                     [0, 64, 0],
  45.                     [128, 64, 0],
  46.                     [0, 192, 0],
  47.                     [128, 192, 0],
  48.                     [0, 64, 128]]
  49.  
  50. # 3. 解码函数
  51. def decoder(pred):
  52.     '''
  53.     :param pred: batchx7x7x30，但是预测的时候一般一张图片一张的放，因此batch=1
  54.     :return: box[[x1,y1,x2,y2]] label[...]
  55.     '''
  56.     # 定义一些基本的参数
  57.     grid_num = 7        # 网格划分标准大小
  58.     #初始化三个空列表，用于存储解码后的边界框坐标、类别索引和对应的概率值。
  59.     boxes=[]
  60.     cls_indexs=[]
  61.     probs = []
  62.     #计算网格单元的大小（或称为缩放因子），这对于将模型输出的坐标从网格空间转换到图像空间是必要的。
  63.     cell_size = 1./grid_num # 缩放因子
  64.     # 获取一些值
  65.     pred = pred.data    # 预测值的数据：1*7*7*30
  66.     pred = pred.squeeze(0) # 预测值的数据：7x7x30
  67.     contain1 = pred[:,:,4].unsqueeze(2)  # 先获取第一个框的置信度，然后升维变为7*7*1
  68.     contain2 = pred[:,:,9].unsqueeze(2) # 同上，只是为第二个框
  69.     contain = torch.cat((contain1,contain2),2) # 拼接在一起，变为7*7*2
  70.     mask1 = contain > 0.1 #大于阈值0.1，设置为True
  71.     mask2 = (contain==contain.max()) # 找出置信度最大的，设置为True
  72.     mask = (mask1+mask2).gt(0) # 将mask1+mask2，让其中大于0的设置为True
  73.     # 开始迭代每个单元格，即7*7个
  74.     for i in range(grid_num):
  75.         for j in range(grid_num):
  76.             # 迭代两个预测框
  77.             for b in range(2):
  78.                 # 如果mask为1，表示这个框是最大的置信度框
  79.                 if mask[i,j,b] == 1:
  80.                     # 获取坐标值
  81.                     box = pred[i,j,b*5:b*5+4]
  82.                     # 获取置信度值
  83.                     contain_prob = torch.FloatTensor([pred[i,j,b*5+4]])
  84.                     # 将7*7的坐标，归一化
  85.                     xy = torch.FloatTensor([j,i])*cell_size #cell左上角  up left of cell
  86.                     #
  87.                     box[:2] = box[:2]*cell_size + xy
  88.                     # 将[cx,cy,w,h]转为[x1,xy1,x2,y2]
  89.                     box_xy = torch.FloatTensor(box.size())      # 重新创建一个变量存储值
  90.                     box_xy[:2] = box[:2] - 0.5*box[2:] # 这个就是中心坐标加减宽度/高度得到左上角/右下角坐标
  91.                     box_xy[2:] = box[:2] + 0.5*box[2:]
  92.                     # 获取最大的概率和类别索引值
  93.                     max_prob,cls_index = torch.max(pred[i,j,10:],0)
  94.                     # 如果置信度 * 类别概率 > 0.1，即说明有一定的可信度
  95.                     # 那么把值加入各个变量列表中
  96.                     if float((contain_prob*max_prob)[0]) > 0.1:
  97.                         boxes.append(box_xy.view(1,4))
  98.                         cls_indexs.append(torch.tensor([cls_index.item()]))
  99.                         probs.append(contain_prob*max_prob)
  100.     # 如果boxes为0，表示没有框，返回0
  101.     if len(boxes) ==0:
  102.         boxes = torch.zeros((1,4))
  103.         probs = torch.zeros(1)
  104.         cls_indexs = torch.zeros(1)
  105.     # 否则，进行处理，就是简单把原来的列表值[tensor,tensor]转为tensor的形式
  106.     # 里面的值不变
  107.     else:
  108.         boxes = torch.cat(boxes,0) #(n,4)
  109.         probs = torch.cat(probs,0) #(n,)
  110.         cls_indexs = torch.cat(cls_indexs,0) #(n,)
  111.     # 后处理——NMS
  112.     keep = mns(boxes,probs)
  113.     # 返回值
  114.     return boxes[keep],cls_indexs[keep],probs[keep]
  115.  
  116. # 4. NMS处理
  117. def mns(bboxes,scores,threshold=0.5):
  118.     '''
  119.     :param bboxes:  bboxes(tensor) [N,4]
  120.     :param scores:  scores(tensor) [N,]
  121.     :param threshold: 阈值
  122.     :return: 返回过滤后的框
  123.     '''
  124.     # 获取各个框的坐标值
  125.     x1 = bboxes[:,0]
  126.     y1 = bboxes[:,1]
  127.     x2 = bboxes[:,2]
  128.     y2 = bboxes[:,3]
  129.     # 计算面积
  130.     areas = (x2-x1) * (y2-y1)
  131.     # 将置信度按照降序排序，并获取排序后的各个置信度在这个顺序中的索引
  132.     _,order = scores.sort(0,descending=True)
  133.     keep = []
  134.     # 判断order中的元素个数是否大于0
  135.     while order.numel() > 0:
  136.         # 如果元素个数只剩下一个了，结束循环
  137.         if order.numel() == 1:
  138.             i = order.item()
  139.             keep.append(i)
  140.             break
  141.         # 获取最大置信度的索引
  142.         i = order[0]
  143.         keep.append(i)
  144.         # 对后面的元素坐标进行截断处理
  145.         xx1 = x1[order[1:]].clamp(min=x1[i]) # min指的是小于它的设置为它的值，大于它的不管
  146.         yy1 = y1[order[1:]].clamp(min=y1[i])
  147.         xx2 = x2[order[1:]].clamp(max=x2[i])
  148.         yy2 = y2[order[1:]].clamp(max=y2[i])
  149.         # 此时的xx1，yy1等是排除了目前选中的框的，即假设x1有三个元素，那么xx1只有2个元素
  150.         # 获取排序后的长和宽以及面积，如果小于0则设置为0
  151.         w = (xx2-xx1).clamp(min=0)
  152.         h = (yy2-yy1).clamp(min=0)
  153.         inter = w*h
  154.  
  155.         # 准备更新order、
  156.         # 计算选中的框和剩下框的IOU值
  157.         ovr = inter / (areas[i] + areas[order[1:]] - inter)
  158.         # 如果 IOU小于设定的阈值，说明需要保存下来继续筛选（NMS原理）
  159.         ids = (ovr<=threshold).nonzero().squeeze()
  160.         if ids.numel() == 0:
  161.             break
  162.         order = order[ids+1]
  163.     return torch.LongTensor(keep)
  164.  
  165. # 5. 预测函数
  166. def predict_single(model, image_name, root_path=''):
  167.     result = []  # 保存结果的变量
  168.     # 打开图片
  169.     image = cv2.imread(root_path + image_name)
  170.     h, w, _ = image.shape
  171.     # resize为模型的输入大小，即448*448
  172.     img = cv2.resize(image, (448, 448))
  173.     # 由于我们模型那里定义的颜色模式为RGB，因此这里需要转换
  174.     mean = (123, 117, 104)  # RGB均值
  175.     img = img - np.array(mean, dtype=np.float32)
  176.     # 预处理
  177.     transform = transforms.Compose([transforms.ToTensor(), ])
  178.     img = transform(img)
  179.     img = Variable(img[None, :, :, :], volatile=True)
  180.     img = img.cuda()
  181.     # 开始预测
  182.     pred = model(img)  # 1x7x7x30
  183.     pred = pred.cpu()
  184.     # 解码
  185.     boxes, cls_indexs, probs = decoder(pred)
  186.     # 开始迭代每个框
  187.     for i, box in enumerate(boxes):
  188.         # 获取相关坐标，只是需要把原来归一化后的坐标转回去
  189.         x1 = int(box[0] * w)
  190.         x2 = int(box[2] * w)
  191.         y1 = int(box[1] * h)
  192.         y2 = int(box[3] * h)
  193.         # 获取类别索引、概率等值
  194.         cls_index = cls_indexs[i]
  195.         cls_index = int(cls_index)  # convert LongTensor to int
  196.         prob = probs[i]
  197.         prob = float(prob)
  198.         # 把这些值集中放入一个变量中返回
  199.         result.append([(x1, y1), (x2, y2), VOC_CLASSES[cls_index], image_name, prob])
  200.     return result
  201.  
  202.  
  203. if __name__ == '__main__':
  204.     # 慢慢的显示
  205.     import time
  206.     # 创建模型，加载参数
  207.     model = resnet50()
  208.     model.load_state_dict(torch.load('./weights/yolo.pth'))
  209.     model.eval()
  210.     model.cuda()
  211.     # 设置图片路径
  212.     base_path = './test_images/'
  213.     # base_path = '../data/VOC2012/JPEGImages/'
  214.     image_name_list = [base_path+i for i in os.listdir(base_path)]
  215.     # 打乱顺序
  216.     random.shuffle(image_name_list)
  217.     print('stating predicting....')
  218.     for image_name in image_name_list:
  219.         image = cv2.imread(image_name)
  220.         image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
  221.         result = predict_single(model, image_name)
  222.         # 画矩形框和对应的类别信息
  223.         for left_up, right_bottom, class_name, _, prob in result:
  224.             # 获取颜色
  225.             color = Color[VOC_CLASSES.index(class_name)]
  226.             # 画矩形
  227.             cv2.rectangle(image, left_up, right_bottom, color, 2)
  228.             # 获取类型信息和对应概率，此时为str类型
  229.             label = class_name + str(round(prob, 2))
  230.             # 把类别和概率信息写上，还要为这个信息加上一个矩形框
  231.             text_size, baseline = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.4, 1)
  232.             p1 = (left_up[0], left_up[1] - text_size[1])
  233.             cv2.rectangle(image, (p1[0] - 2 // 2, p1[1] - 2 - baseline), (p1[0] + text_size[0], p1[1] + text_size[1]),
  234.                           color, -1)
  235.             cv2.putText(image, label, (p1[0], p1[1] + baseline), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (255, 255, 255), 1, 8)
  236.  
  237.         # 显示图片
  238.         plt.figure()
  239.         plt.imshow(image)
  240.         plt.show()
  241.         time.sleep(2)
  242.         # 是否保存结果图片
  243.         cv2.imwrite('./test_images/result.jpg', image)

6、验证图片

 

7、完整代码和权重下载

链接：https://pan.baidu.com/s/1nJbfAxTUshCy4giFPoy7sA 
提取码：yov1 

8、总结

需要改进：

  首先，肯定是batch_size的大小，如果有得选，我也想把batch_size改大一点_
  其次，是优化器的选择和其参数的设置，本次选用的SGD，参数都是默认设置的，我在想是否改为Adam会好一点
  另外，本次学习率从0.01开始，分别在20和35epoch时除以10，感觉初始的学习率有点大了，是否可以减小学习率？
  最后，所谓微调，我们继承了ResNet50的权重，但是这个ResNet50是在尺度为224*224下训练的，而我们的目标检测将分辨率改为了448*448，是否需要先进行一定程度的微调才来训练yolov1值得思考。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/480555
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号