关键词：
前言：
本专栏以理论与实战相结合的方式，左手看论文，右手敲代码，带你一步步吃透深度学习原理和源码，逐一攻克计算机视觉领域中的三大基本任务：图像分类、目标检测、语义分割。
本专栏完整代码将在我的GiuHub仓库更新，欢迎star收藏：https://github.com/Keyird/DeepLearning-TensorFlow2
文章目录
资源获取：
YOLOv4 算法讲解：https://ai-wx.blog.csdn.net/article/details/116793973
YOLOv4 代码仓库：https://github.com/Keyird/TensorFlow2-Detection/tree/main/YOLOv4
VOC2007 数据集下载：https://pan.baidu.com/s/1lyiA3uzQhRLTaO2Xov5BHQ 提取码：wm4l
预训练模型下载链接：https://pan.baidu.com/s/1KFwAqsnBv24vBEpdFgZvIA 提取码：ce1v
一、VOC数据集构建
（1）VOC格式介绍
VOC 是目标检测一种通用的标准数据集格式，下面我以VOC2007数据集为例，来制作VOC标准数据集。整个数据集文件的目录结构如下图所示：
其中，VOC2007目录下存在着三个不同的文件，其具体作用是：
- Annotations：存放数据集的xml标签文件，xml文件需要进行解析。
- ImageSets：用来存放训练集或者测试集中图片ID的txt文件。
- JPEGImages：存放数据集原图
如果自己没有准备数据集，可以直接使用VOC2007数据集进行实验，数据集下载方式见上文。
（2）划分数据集
按照一定的比例划分数据集，并将图像数据的文件名（ID）存放在各个不同的txt文件中。比如我们要使用训练集数据，就从读取train.txt文件中存储ID对应的图像数据。
xmlfilepath = "./Annotations"
saveBasePath = "./ImageSets/Main/"
# 打开（新建）txt文件，用来存放待训练/测试数据的ID
ftrainval = open(os.path.join(saveBasePath,'trainval.txt'), 'w')
ftest = open(os.path.join(saveBasePath,'test.txt'), 'w')
ftrain = open(os.path.join(saveBasePath,'train.txt'), 'w')
fval = open(os.path.join(saveBasePath,'val.txt'), 'w')
# 按比例分配数据
for i in list:
name=total_xml[i][:-4]+'\\n'
if i in trainval:
ftrainval.write(name)
if i in train:
ftrain.write(name)
else:
fval.write(name)
else:
ftest.write(name)
# 关闭（保存）txt文件
ftrainval.close()
ftrain.close()
fval.close()
ftest .close()
（3）解析xml标签
通过下面的 convert_annotation() 函数对 xml 标签进行解析，并将原图路径和对应的解析后的标签写入并保存在list_file文件夹中。
# 解析xml,获得标签值，并向txt中写入标签
def convert_annotation(year, image_id, list_file):
in_file = open('VOCdevkit/VOC%s/Annotations/%s.xml'%(year, image_id))
tree = ET.parse(in_file)
root = tree.getroot()
for obj in root.iter('object'):
difficult = 0
if obj.find('difficult')!=None:
difficult = obj.find('difficult').text
cls = obj.find('name').text
if cls not in classes or int(difficult)==1:
continue
cls_id = classes.index(cls)
xmlbox = obj.find('bndbox')
b = (int(xmlbox.find('xmin').text), int(xmlbox.find('ymin').text), int(xmlbox.find('xmax').text), int(xmlbox.find('ymax').text))
list_file.write(" " + ",".join([str(a) for a in b]) + ',' + str(cls_id))
二、YOLOv4网络构建
YOLOv4的整体网络架构如下，下面将按照如下框架图来逐一搭建YOLOv4中的各个结构单元。
（1）DBL模块
def DarknetConv2D_BN_Leaky(*args, **kwargs):
"""
DarknetConv2D + BatchNormalization + LeakyReLU
"""
no_bias_kwargs = 'use_bias': False
no_bias_kwargs.update(kwargs)
return compose(
DarknetConv2D(*args, **no_bias_kwargs),
BatchNormalization(),
LeakyReLU(alpha=0.1))
（2）DBM模块
def DarknetConv2D_BN_Mish(*args, **kwargs):
"""
DarknetConv2D + BatchNormalization + Mish
"""
no_bias_kwargs = 'use_bias': False
no_bias_kwargs.update(kwargs)
return compose(
DarknetConv2D(*args, **no_bias_kwargs),
BatchNormalization(),
Mish())
（3）Resblock_Body
def resblock_body(x, num_filters, num_blocks, all_narrow=True):
"""
CSPDarknet53中的残差块
"""
# 利用ZeroPadding2D和一个步长为2x2的卷积块进行高和宽的压缩
preconv1 = ZeroPadding2D(((1,0),(1,0)))(x)
preconv1 = DarknetConv2D_BN_Mish(num_filters, (3,3), strides=(2,2))(preconv1)
# 然后建立一个大的残差边shortconv、这个大残差边绕过了很多的残差结构
shortconv = DarknetConv2D_BN_Mish(num_filters//2 if all_narrow else num_filters, (1,1))(preconv1)
# 主干部分会对num_blocks进行循环，循环内部是残差结构
mainconv = DarknetConv2D_BN_Mish(num_filters//2 if all_narrow else num_filters, (1,1))(preconv1)
for i in range(num_blocks):
y = compose(
DarknetConv2D_BN_Mish(num_filters//2, (1,1)),
DarknetConv2D_BN_Mish(num_filters//2 if all_narrow else num_filters, (3,3)))(mainconv)
mainconv = Add()([mainconv,y])
postconv = DarknetConv2D_BN_Mish(num_filters//2 if all_narrow else num_filters, (1,1))(mainconv)
# 将大残差边再堆叠回来
route = Concatenate()([postconv, shortconv])
# 最后对通道数进行整合
return DarknetConv2D_BN_Mish(num_filters, (1,1))(route)
（4）CSPDarknet53
def darknet_body(x):
"""
CSPDarknet53
"""
x = DarknetConv2D_BN_Mish(32, (3,3))(x)
x = resblock_body(x, 64, 1, False)
x = resblock_body(x, 128, 2)
x = resblock_body(x, 256, 8)
feat1 = x
x = resblock_body(x, 512, 8)
feat2 = x
x = resblock_body(x, 1024, 4)
feat3 = x
return feat1,feat2,feat3
（5）YOLOv4整体结构
def yolo_body(inputs, num_anchors, num_classes):
"""
构建YOLOv4整体结构
获得三个有效特征层，他们的shape分别是：(52,52,256)、(26,26,512)、(13,13,1024)
输出的是3个不同shape的预测张量，包含的是相对GT的偏移和真实类别、得分信息
"""
# 分别获得三个预测分支
feat1, feat2, feat3 = darknet_body(inputs)
# 13,13,1024 -> 13,13,512 -> 13,13,1024 -> 13,13,512 -> 13,13,2048 -> 13,13,512 -> 13,13,1024 -> 13,13,512
P5 = DarknetConv2D_BN_Leaky(512, (1, 1))(feat3)
P5 = DarknetConv2D_BN_Leaky(1024, (3, 3))(P5)
P5 = DarknetConv2D_BN_Leaky(512, (1, 1))(P5)
# 使用了SPP结构，即不同尺度的最大池化后堆叠。
maxpool1 = MaxPooling2D(pool_size=(13, 13), strides=(1, 1), padding='same')(P5)
maxpool2 = MaxPooling2D(pool_size=(9, 9), strides=(1, 1), padding='same')(P5)
maxpool3 = MaxPooling2D(pool_size=(5, 5), strides=(1, 1), padding='same')(P5)
P5 = Concatenate()([maxpool1, maxpool2, maxpool3, P5])
P5 = DarknetConv2D_BN_Leaky(512, (1, 1))(P5)
P5 = DarknetConv2D_BN_Leaky(1024, (3, 3))(P5)
P5 = DarknetConv2D_BN_Leaky(512, (1, 1))(P5)
# 13,13,512 -> 13,13,256 -> 26,26,256
P5_upsample = compose(DarknetConv2D_BN_Leaky(256, (1, 1)), UpSampling2D(2))(P5)
# 26,26,512 -> 26,26,256
P4 = DarknetConv2D_BN_Leaky(256, (1, 1))(feat2)
# 26,26,256 + 26,26,256 -> 26,26,512
P4 = Concatenate()([P4, P5_upsample])
# 26,26,512 -> 26,26,256 -> 26,26,512 -> 26,26,256 -> 26,26,512 -> 26,26,256
P4 = make_five_convs(P4, 256)
# 26,26,256 -> 26,26,128 -> 52,52,128
P4_upsample = compose(DarknetConv2D_BN_Leaky(128, (1, 1)), UpSampling2D(2))(P4)
# 52,52,256 -> 52,52,128
P3 = DarknetConv2D_BN_Leaky(128, (1, 1))(feat1)
# 52,52,128 + 52,52,128 -> 52,52,256
P3 = Concatenate()([P3, P4_upsample])
# 52,52,256 -> 52,52,128 -> 52,52,256 -> 52,52,128 -> 52,52,256 -> 52,52,128
P3 = make_five_convs(P3, 128)
# ---------------------------------------------------#
# 第三个特征层
# y3=(batch_size,52,52,3,85)
# ---------------------------------------------------#
P3_output = DarknetConv2D_BN_Leaky(256, (3, 3))(P3)
P3_output = DarknetConv2D(num_anchors * (num_classes + 5), (1, 1),
kernel_initializer=keras.initializers.RandomNormal(mean=0.0, stddev=0.01))(P3_output)
# 52,52,128 -> 26,26,256
P3_downsample = ZeroPadding2D(((1, 0), (1, 0)))(P3)
P3_downsample = DarknetConv2D_BN_Leaky(256, (3, 3), strides=(2, 2))(P3_downsample)
# 26,26,256 + 26,26,256 -> 26,26,512
P4 = Concatenate()([P3_downsample, P4])
# 26,26,512 -> 26,26,256 -> 26,26,512 -> 26,26,256 -> 26,26,512 -> 26,26,256
P4 = make_five_convs(P4, 256)
# ---------------------------------------------------#
# 第二个特征层
# y2=(batch_size,26,26,3,85)
# ---------------------------------------------------#
P4_output = DarknetConv2D_BN_Leaky(512, (3, 3))(P4)
P4_output = DarknetConv2D(num_anchors * (num_classes + 5), (1, 1),
kernel_initializer=keras.initializers.RandomNormal(mean=0.0, stddev=0.01))(P4_output)
# 26,26,256 -> 13,13,512
P4_downsample = ZeroPadding2D(((1, 0), (1, 0)))(P4)
P4_downsample = DarknetConv2D_BN_Leaky(512, (3, 3), strides=(2, 2))(P4_downsample)
# 13,13,512 + 13,13,512 -> 13,13,1024
P5 = Concatenate()([P4_downsample, P5])
# 13,13,1024 -> 13,13,512 -> 13,13,1024 -> 13,13,512 -> 13,13,1024 -> 13,13,512
P5 = make_five_convs(P5, 512)
# ---------------------------------------------------#
# 第一个特征层
# y1=(batch_size,13,13,3,85)
# ---------------------------------------------------#
P5_output = DarknetConv2D_BN_Leaky(1024, (3, 3))(P5)
P5_output = DarknetConv2D(num_anchors * (num_classes + 5), (1, 1),
kernel_initializer=keras.initializers.RandomNormal(mean=0.0, stddev=0.01))(P5_output)
return Model(inputs, [P5_output, P4_output, P3_output])
三、计算损失误差
（1）调整成真实值
根据YOLOv4目标检测原理可知，YOLOv4网络直接输出的不是目标框的真实位置，而是相对位置。所以，在根据预测值和标签值计算损失之前，需要将YOLOv4网络预测的相对位置转换成真实预测位置，完成这一步，需要进行如下操作：
def yolo_head(feats, anchors, num_classes, input_shape, calc_loss=False):
"""
将yolo_body()输出的预测值的调整成真实值
"""
num_anchors = len(anchors)
# [1, 1, 1, num_anchors, 2]
feats = tf.convert_to_tensor(feats)
anchors_tensor = K.reshape(K.constant(anchors), [1, 1, 1, num_anchors, 2])
# 获得x，y的网格
# (13, 13, 1, 2)
grid_shape = K.shape(feats)[1:3] # height, width
grid_y = K.tile(K.reshape(K.arange(0, stop=grid_shape[0]), [-1, 1, 1, 1]),
[1, grid_shape[1], 1, 1])
grid_x = K.tile(K.reshape(K.arange(0, stop=grid_shape[1]), [1, -1, 1, 1]),
[grid_shape[0], 1, 1, 1])
grid = K.concatenate([grid_x, grid_y])
grid = K.cast(grid, K.dtype(feats))
# 将预测结果调整成(batch_size,13,13,3,85)
# 85可拆分成4 + 1 + 80
# 4代表的是中心宽高的调整参数，1代表的是框的置信度，80代表的是种类的置信度
feats = K.reshape(feats, [-1, grid_shape[0], grid_shape[1], num_anchors, num_classes + 5])
# 将预测值调成真实值：box_xy对应框的中心点，box_wh对应框的宽和高
box_xy = (K.sigmoid(feats[..., :2]) + grid) / K.cast(grid_shape[...,::-1], K.dtype(feats)) # 调整后的x,y
box_wh = K.exp(feats[..., 2:4]) * anchors_tensor / K.cast(input_shape[...,::-1], K.dtype(feats)) # 调整后的w,h
box_confidence = K.sigmoid(feats[..., 4:5]) # 置信度confidence
box_class_probs = K.sigmoid(feats[..., 5:]) # 类别
# 在计算loss的时候返回grid, feats, box_xy, box_wh
# 在预测的时候返回box_xy, box_wh, box_confidence, box_class_probs
if calc_loss == True:
return grid, feats, box_xy, box_wh
return box_xy, box_wh查看详情
tensorflow2深度学习实战（十八）：目标检测算法yolov4-tiny实战
...ub仓库更新，欢迎star收藏：https://github.com/Keyird/DeepLearning-TensorFlow2文章目录一、实战介绍与说明（1）代码结构说明（2）如何使用本项目进行预测二、VOC数据集构建（1）VOC格式介绍（2）划分数据集（3）解析xml标签三、网络结构... 查看详情
tensorflow2深度学习实战（十八）：目标检测算法yolov4-tiny实战
...ub仓库更新，欢迎star收藏：https://github.com/Keyird/DeepLearning-TensorFlow2文章目录一、实战介绍与说明（1）代码结构说明（2）如何使用本项目进行预测二、VOC数据集构建（1）VOC格式介绍（2）划分数据集（3）解析xml标签三、网络结构... 查看详情
tensorflow2深度学习实战（十八）：目标检测算法yolov4-tiny实战
...ub仓库更新，欢迎star收藏：https://github.com/Keyird/DeepLearning-TensorFlow2文章目录一、实战介绍与说明（1）代码结构说明（2）如何使用本项目进行预测二、VOC数据集构建（1）VOC格式介绍（2）划分数据集（3）解析xml标签三、网络结构... 查看详情
tensorflow2深度学习实战（十六）：目标检测算法fasterr-cnn解析
本专栏以理论与实战相结合的方式，左手看论文，右手撸代码，带你一步步掌握深度学习原理和源码，玩转计算机视觉领域中的三大基本任务：图像分类、目标检测、语义分割。本专栏完整代码将在我的GiuHub... 查看详情
tf2深度学习实战（十五）：yolov4目标检测网络实战(代码片段)
文章目录一、VOC数据集构建（1）VOC格式介绍（2）划分数据集（3）解析xml标签二、YOLOv4网络构建（1）DBL模块（2）DBM模块（3）Resblock_Body（4）CSPDarknet53& 查看详情
tensorflow2深度学习实战（十三）：语义分割算法segnet实战(代码片段)
...部分对SegNet算法进行必要的讲解，然后在实战部分，使用TensorFlow2框架搭建SegNet网络，实现对场景中的目标（矿堆）进行分割。分割结果如下：文章目录一、SegNet算法详解 查看详情
tensorflow2深度学习实战（十六）：目标检测算法fasterr-cnn解析
...新，欢迎star收藏：https://github.com/Keyird/DeepLearning-TensorFlow2文章目录一、FasterR-CNN介绍二、算法流程三、网络结构1、Convlayers2、RegionProposalNetworks3、ROIPooling4、ClassiferandDetector四、损失函数五、网络训练一、FasterR-CNN介绍2015年... 查看详情
谈谈基于深度学习的目标检测网络为什么会误检，以及如何优化目标检测的误检问题
添加链接描述 查看详情
谈谈基于深度学习的目标检测网络为什么会误检，以及如何优化目标检测的误检问题
添加链接描述 查看详情
实战深度学习目标检测：rcnn
深度学习目标检测：RCNN什么是目标检测？目标检测主要是明确从图中看到了什么物体？他们在什么位置。传统的目标检测方法一般分为三个阶段：首先在给定的图像上选择一些候选的区域，然后对这些区域提... 查看详情
tensorflow2深度学习基础和tf.keras(代码片段)
代码和其他资料在github一、tf.keras概述首先利用tf.keras实现一个简单的线性回归，如(f(x)=ax+b)，其中(x)代表学历，(f(x))代表收入，分别代表输入特征和输出值。为了描述预测目标与真实值之间的整体误差最小，需要定义一个损失函... 查看详情
keras深度学习实战（13）——目标检测基础详解(代码片段)
Keras深度学习实战（13）——目标检测基础详解0.前言1.目标检测概念2.创建自定义目标检测数据集2.1windows2.2Ubuntu2.3MacOS3.使用选择性搜索在图像内生成候选区域3.1候选区域3.2选择性搜索3.3使用选择性搜索生成候选区域4.交并... 查看详情
keras深度学习实战（15）——从零开始实现yolo目标检测(代码片段)
Keras深度学习实战（15）——从零开始实现YOLO目标检测0.前言1.YOLO目标检测模型1.1锚框(anchorboxes)1.2YOLO目标检测模型原理2.从零开始实现YOLO目标检测2.1加载数据集2.2计算锚框尺寸2.3创建训练数据集2.4实现YOLO目标检测模型2.5... 查看详情
实战深度学习目标检测：rcnn
FasterR-CNN使用的检测框架是RPN网络+FastR-CNN网络分离进行的目标检测，整体流程跟FastR-CNN一样，只是regionproposal现在是用RPN网络提取的（代替原来的selectivesearch）。RPN的核心思想是使用卷积神经网络直接产生regionp... 查看详情
学习tensorflow2环境配置(代码片段)
活动地址：CSDN21天学习挑战赛创作计划**1，机缘前几天看到了这个21天学习挑战赛，就挑了一个看起来最贵的报名参加开玩笑啦，实际上主要一直对深度学习特别好奇，但是自己一直没有真的去行动过，... 查看详情
学习tensorflow2环境配置(代码片段)
活动地址：CSDN21天学习挑战赛创作计划**1，机缘前几天看到了这个21天学习挑战赛，就挑了一个看起来最贵的报名参加开玩笑啦，实际上主要一直对深度学习特别好奇，但是自己一直没有真的去行动过，... 查看详情
pytorch深度学习实战|基于yolov3的安全帽佩戴检测
本期将提供一个利用深度学习检测是否佩戴安全帽的案例，从而展示计算机视觉中的目标识别问题的一般流程。目标检测是基于图片分类的计算机视觉任务，既包含了分类，又包含了定位。给出一张图片，目标检测系统要能够识... 查看详情