- 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
- 🍖 原作者：K同学啊 | 接辅导、项目定制
文章目录
前言
本文将采用pytorch框架创建YOLOv5-C3模块实现天气识别。讲述实现代码与执行结果，并浅谈涉及知识点。
关键字： YOLOV5 Backbone
1 我的环境
- 电脑系统：Windows 11
- 语言环境：python 3.8.6
- 编译器：pycharm2020.2.3
- 深度学习环境：
torch == 1.9.1+cu111
torchvision == 0.10.1+cu111 - 显卡：NVIDIA GeForce RTX 4070
2 代码实现与执行结果
2.1 前期准备
2.1.1 引入库
import torch
import torch.nn as nn
from torchvision import transforms, datasets
import time
from pathlib import Path
from PIL import Image
import torchsummary as summary
import torch.nn.functional as F
import copy
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif'] = ['SimHei'] # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False # 用来正常显示负号
plt.rcParams['figure.dpi'] = 100 # 分辨率
import warnings
warnings.filterwarnings('ignore') # 忽略一些warning内容，无需打印
2.1.2 设置GPU（如果设备上支持GPU就使用GPU,否则使用CPU）
"""前期准备-设置GPU"""
# 如果设备上支持GPU就使用GPU,否则使用CPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("Using {} device".format(device))
输出
Using cuda device
2.1.3 导入数据
'''前期工作-导入数据'''
data_dir = r"D:\DeepLearning\data\CoffeeBean"
data_dir = Path(data_dir)
data_paths = list(data_dir.glob('*'))
classeNames = [str(path).split("\\")[-1] for path in data_paths]
print(classeNames)
输出
['cloudy', 'rain', 'shine', 'sunrise']
2.1.4 可视化数据
'''前期工作-可视化数据'''
subfolder = Path(data_dir)/"Angelina Jolie"
image_files = list(p.resolve() for p in subfolder.glob('*') if p.suffix in [".jpg", ".png", ".jpeg"])
plt.figure(figsize=(10, 6))
for i in range(len(image_files[:12])):
image_file = image_files[i]
ax = plt.subplot(3, 4, i + 1)
img = Image.open(str(image_file))
plt.imshow(img)
plt.axis("off")
# 显示图片
plt.tight_layout()
plt.show()
2.1.4 图像数据变换
'''前期工作-图像数据变换'''
total_datadir = data_dir
# 关于transforms.Compose的更多介绍可以参考：https://blog.csdn.net/qq_38251616/article/details/124878863
train_transforms = transforms.Compose([
transforms.Resize([224, 224]), # 将输入图片resize成统一尺寸
transforms.ToTensor(), # 将PIL Image或numpy.ndarray转换为tensor，并归一化到[0,1]之间
transforms.Normalize( # 标准化处理-->转换为标准正太分布（高斯分布），使模型更容易收敛
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]) # 其中 mean=[0.485,0.456,0.406]与std=[0.229,0.224,0.225] 从数据集中随机抽样计算得到的。
])
total_data = datasets.ImageFolder(total_datadir, transform=train_transforms)
print(total_data)
print(total_data.class_to_idx)
输出
Dataset ImageFolder
Number of datapoints: 1125
Root location: D:\DeepLearning\data\weather_photos
StandardTransform
Transform: Compose(
Resize(size=[224, 224], interpolation=bilinear, max_size=None, antialias=None)
ToTensor()
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
)
{'cloudy': 0, 'rain': 1, 'shine': 2, 'sunrise': 3}
2.1.4 划分数据集
'''前期工作-划分数据集'''
train_size = int(0.8 * len(total_data)) # train_size表示训练集大小，通过将总体数据长度的80%转换为整数得到；
test_size = len(total_data) - train_size # test_size表示测试集大小，是总体数据长度减去训练集大小。
# 使用torch.utils.data.random_split()方法进行数据集划分。该方法将总体数据total_data按照指定的大小比例（[train_size, test_size]）随机划分为训练集和测试集，
# 并将划分结果分别赋值给train_dataset和test_dataset两个变量。
train_dataset, test_dataset = torch.utils.data.random_split(total_data, [train_size, test_size])
print("train_dataset={}\ntest_dataset={}".format(train_dataset, test_dataset))
print("train_size={}\ntest_size={}".format(train_size, test_size))
输出
train_dataset=<torch.utils.data.dataset.Subset object at 0x0000020A3A209730>
test_dataset=<torch.utils.data.dataset.Subset object at 0x0000020A3A209BB0>
train_size=900
test_size=225
2.1.4 加载数据
'''前期工作-加载数据'''
batch_size = 32
train_dl = torch.utils.data.DataLoader(train_dataset,
batch_size=batch_size,
shuffle=True,
num_workers=1)
test_dl = torch.utils.data.DataLoader(test_dataset,
batch_size=batch_size,
shuffle=True,
num_workers=1)
2.1.4 查看数据
'''前期工作-查看数据'''
for X, y in test_dl:
print("Shape of X [N, C, H, W]: ", X.shape)
print("Shape of y: ", y.shape, y.dtype)
break
输出
Shape of X [N, C, H, W]: torch.Size([32, 3, 224, 224])
Shape of y: torch.Size([32]) torch.int64
2.2 搭建包含Backbone模块的模型
import torch.nn.functional as F
def autopad(k, p=None): # kernel, padding
# Pad to 'same'
if p is None:
p = k // 2 if isinstance(k, int) else [x // 2 for x in k] # auto-pad
return p
class Conv(nn.Module):
# Standard convolution
def __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True): # ch_in, ch_out, kernel, stride, padding, groups
super().__init__()
self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p), groups=g, bias=False)
self.bn = nn.BatchNorm2d(c2)
self.act = nn.SiLU() if act is True else (act if isinstance(act, nn.Module) else nn.Identity())
def forward(self, x):
return self.act(self.bn(self.conv(x)))
class Bottleneck(nn.Module):
# Standard bottleneck
def __init__(self, c1, c2, shortcut=True, g=1, e=0.5): # ch_in, ch_out, shortcut, groups, expansion
super().__init__()
c_ = int(c2 * e) # hidden channels
self.cv1 = Conv(c1, c_, 1, 1)
self.cv2 = Conv(c_, c2, 3, 1, g=g)
self.add = shortcut and c1 == c2
def forward(self, x):
return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))
class C3(nn.Module):
# CSP Bottleneck with 3 convolutions
def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5): # ch_in, ch_out, number, shortcut, groups, expansion
super().__init__()
c_ = int(c2 * e) # hidden channels
self.cv1 = Conv(c1, c_, 1, 1)
self.cv2 = Conv(c1, c_, 1, 1)
self.cv3 = Conv(2 * c_, c2, 1) # act=FReLU(c2)
self.m = nn.Sequential(*(Bottleneck(c_, c_, shortcut, g, e=1.0) for _ in range(n)))
def forward(self, x):
return self.cv3(torch.cat((self.m(self.cv1(x)), self.cv2(x)), dim=1))
class SPPF(nn.Module):
# Spatial Pyramid Pooling - Fast (SPPF) layer for YOLOv5 by Glenn Jocher
def __init__(self, c1, c2, k=5): # equivalent to SPP(k=(5, 9, 13))
super().__init__()
c_ = c1 // 2 # hidden channels
self.cv1 = Conv(c1, c_, 1, 1)
self.cv2 = Conv(c_ * 4, c2, 1, 1)
self.m = nn.MaxPool2d(kernel_size=k, stride=1, padding=k // 2)
def forward(self, x):
x = self.cv1(x)
with warnings.catch_warnings():
warnings.simplefilter('ignore') # suppress torch 1.9.0 max_pool2d() warning
y1 = self.m(x)
y2 = self.m(y1)
return self.cv2(torch.cat([x, y1, y2, self.m(y2)], 1))
"""
这个是YOLOv5, 6.0版本的主干网络，这里进行复现
（注：有部分删改，详细讲解将在后续进行展开）
"""
class YOLOv5_backbone(nn.Module):
def __init__(self):
super(YOLOv5_backbone, self).__init__()
self.Conv_1 = Conv(3, 64, 3, 2, 2)
self.Conv_2 = Conv(64, 128, 3, 2)
self.C3_3 = C3(128,128)
self.Conv_4 = Conv(128, 256, 3, 2)
self.C3_5 = C3(256,256)
self.Conv_6 = Conv(256, 512, 3, 2)
self.C3_7 = C3(512,512)
self.Conv_8 = Conv(512, 1024, 3, 2)
self.C3_9 = C3(1024, 1024)
self.SPPF = SPPF(1024, 1024, 5)
# 全连接网络层，用于分类
self.classifier = nn.Sequential(
nn.Linear(in_features=65536, out_features=100),
nn.ReLU(),
nn.Linear(in_features=100, out_features=4)
)
def forward(self, x):
x = self.Conv_1(x)
x = self.Conv_2(x)
x = self.C3_3(x)
x = self.Conv_4(x)
x = self.C3_5(x)
x = self.Conv_6(x)
x = self.C3_7(x)
x = self.Conv_8(x)
x = self.C3_9(x)
x = self.SPPF(x)
x = torch.flatten(x, start_dim=1)
x = self.classifier(x)
return x
device = "cuda" if torch.cuda.is_available() else "cpu"
print("Using {} device".format(device))
model = YOLOv5_backbone().to(device)
print(summary.summary(model, (3, 224, 224)))#查看模型的参数量以及相关指标
输出
----------------------------------------------------------------
Layer (type) Output Shape Param #
================================================================
Conv2d-1 [-1, 64, 113, 113] 1,728
BatchNorm2d-2 [-1, 64, 113, 113] 128
SiLU-3 [-1, 64, 113, 113] 0
Conv-4 [-1, 64, 113, 113] 0
Conv2d-5 [-1, 128, 57, 57] 73,728
BatchNorm2d-6 [-1, 128, 57, 57] 256
SiLU-7 [-1, 128, 57, 57] 0
Conv-8 [-1, 128, 57, 57] 0
Conv2d-9 [-1, 64, 57, 57] 8,192
BatchNorm2d-10 [-1, 64, 57, 57] 128
SiLU-11 [-1, 64, 57, 57] 0
Conv-12 [-1, 64, 57, 57] 0
Conv2d-13 [-1, 64, 57, 57] 4,096
BatchNorm2d-14 [-1, 64, 57, 57] 128
SiLU-15 [-1, 64, 57, 57] 0
Conv-16 [-1, 64, 57, 57] 0
Conv2d-17 [-1, 64, 57, 57] 36,864
BatchNorm2d-18 [-1, 64, 57, 57] 128
SiLU-19 [-1, 64, 57, 57] 0
Conv-20 [-1, 64, 57, 57] 0
Bottleneck-21 [-1, 64, 57, 57] 0
Conv2d-22 [-1, 64, 57, 57] 8,192
BatchNorm2d-23 [-1, 64, 57, 57] 128
SiLU-24 [-1, 64, 57, 57] 0
Conv-25 [-1, 64, 57, 57] 0
Conv2d-26 [-1, 128, 57, 57] 16,384
BatchNorm2d-27 [-1, 128, 57, 57] 256
SiLU-28 [-1, 128, 57, 57] 0
Conv-29 [-1, 128, 57, 57] 0
C3-30 [-1, 128, 57, 57] 0
Conv2d-31 [-1, 256, 29, 29] 294,912
BatchNorm2d-32 [-1, 256, 29, 29] 512
SiLU-33 [-1, 256, 29, 29] 0
Conv-34 [-1, 256, 29, 29] 0
Conv2d-35 [-1, 128, 29, 29] 32,768
BatchNorm2d-36 [-1, 128, 29, 29] 256
SiLU-37 [-1, 128, 29, 29] 0
Conv-38 [-1, 128, 29, 29] 0
Conv2d-39 [-1, 128, 29, 29] 16,384
BatchNorm2d-40 [-1, 128, 29, 29] 256
SiLU-41 [-1, 128, 29, 29] 0
Conv-42 [-1, 128, 29, 29] 0
Conv2d-43 [-1, 128, 29, 29] 147,456
BatchNorm2d-44 [-1, 128, 29, 29] 256
SiLU-45 [-1, 128, 29, 29] 0
Conv-46 [-1, 128, 29, 29] 0
Bottleneck-47 [-1, 128, 29, 29] 0
Conv2d-48 [-1, 128, 29, 29] 32,768
BatchNorm2d-49 [-1, 128, 29, 29] 256
SiLU-50 [-1, 128, 29, 29] 0
Conv-51 [-1, 128, 29, 29] 0
Conv2d-52 [-1, 256, 29, 29] 65,536
BatchNorm2d-53 [-1, 256, 29, 29] 512
SiLU-54 [-1, 256, 29, 29] 0
Conv-55 [-1, 256, 29, 29] 0
C3-56 [-1, 256, 29, 29] 0
Conv2d-57 [-1, 512, 15, 15] 1,179,648
BatchNorm2d-58 [-1, 512, 15, 15] 1,024
SiLU-59 [-1, 512, 15, 15] 0
Conv-60 [-1, 512, 15, 15] 0
Conv2d-61 [-1, 256, 15, 15] 131,072
BatchNorm2d-62 [-1, 256, 15, 15] 512
SiLU-63 [-1, 256, 15, 15] 0
Conv-64 [-1, 256, 15, 15] 0
Conv2d-65 [-1, 256, 15, 15] 65,536
BatchNorm2d-66 [-1, 256, 15, 15] 512
SiLU-67 [-1, 256, 15, 15] 0
Conv-68 [-1, 256, 15, 15] 0
Conv2d-69 [-1, 256, 15, 15] 589,824
BatchNorm2d-70 [-1, 256, 15, 15] 512
SiLU-71 [-1, 256, 15, 15] 0
Conv-72 [-1, 256, 15, 15] 0
Bottleneck-73 [-1, 256, 15, 15] 0
Conv2d-74 [-1, 256, 15, 15] 131,072
BatchNorm2d-75 [-1, 256, 15, 15] 512
SiLU-76 [-1, 256, 15, 15] 0
Conv-77 [-1, 256, 15, 15] 0
Conv2d-78 [-1, 512, 15, 15] 262,144
BatchNorm2d-79 [-1, 512, 15, 15] 1,024
SiLU-80 [-1, 512, 15, 15] 0
Conv-81 [-1, 512, 15, 15] 0
C3-82 [-1, 512, 15, 15] 0
Conv2d-83 [-1, 1024, 8, 8] 4,718,592
BatchNorm2d-84 [-1, 1024, 8, 8] 2,048
SiLU-85 [-1, 1024, 8, 8] 0
Conv-86 [-1, 1024, 8, 8] 0
Conv2d-87 [-1, 512, 8, 8] 524,288
BatchNorm2d-88 [-1, 512, 8, 8] 1,024
SiLU-89 [-1, 512, 8, 8] 0
Conv-90 [-1, 512, 8, 8] 0
Conv2d-91 [-1, 512, 8, 8] 262,144
BatchNorm2d-92 [-1, 512, 8, 8] 1,024
SiLU-93 [-1, 512, 8, 8] 0
Conv-94 [-1, 512, 8, 8] 0
Conv2d-95 [-1, 512, 8, 8] 2,359,296
BatchNorm2d-96 [-1, 512, 8, 8] 1,024
SiLU-97 [-1, 512, 8, 8] 0
Conv-98 [-1, 512, 8, 8] 0
Bottleneck-99 [-1, 512, 8, 8] 0
Conv2d-100 [-1, 512, 8, 8] 524,288
BatchNorm2d-101 [-1, 512, 8, 8] 1,024
SiLU-102 [-1, 512, 8, 8] 0
Conv-103 [-1, 512, 8, 8] 0
Conv2d-104 [-1, 1024, 8, 8] 1,048,576
BatchNorm2d-105 [-1, 1024, 8, 8] 2,048
SiLU-106 [-1, 1024, 8, 8] 0
Conv-107 [-1, 1024, 8, 8] 0
C3-108 [-1, 1024, 8, 8] 0
Conv2d-109 [-1, 512, 8, 8] 524,288
BatchNorm2d-110 [-1, 512, 8, 8] 1,024
SiLU-111 [-1, 512, 8, 8] 0
Conv-112 [-1, 512, 8, 8] 0
MaxPool2d-113 [-1, 512, 8, 8] 0
MaxPool2d-114 [-1, 512, 8, 8] 0
MaxPool2d-115 [-1, 512, 8, 8] 0
Conv2d-116 [-1, 1024, 8, 8] 2,097,152
BatchNorm2d-117 [-1, 1024, 8, 8] 2,048
SiLU-118 [-1, 1024, 8, 8] 0
Conv-119 [-1, 1024, 8, 8] 0
SPPF-120 [-1, 1024, 8, 8] 0
Linear-121 [-1, 100] 6,553,700
ReLU-122 [-1, 100] 0
Linear-123 [-1, 4] 404
================================================================
Total params: 21,729,592
Trainable params: 21,729,592
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.57
Forward/backward pass size (MB): 137.59
Params size (MB): 82.89
Estimated Total Size (MB): 221.06
----------------------------------------------------------------
2.3 训练模型
2.3.1 设置超参数
"""训练模型--设置超参数"""
loss_fn = nn.CrossEntropyLoss() # 创建损失函数，计算实际输出和真实相差多少，交叉熵损失函数，事实上，它就是做图片分类任务时常用的损失函数
learn_rate = 1e-4 # 学习率
optimizer1 = torch.optim.SGD(model.parameters(), lr=learn_rate)# 作用是定义优化器，用来训练时候优化模型参数；其中，SGD表示随机梯度下降，用于控制实际输出y与真实y之间的相差有多大
optimizer2 = torch.optim.Adam(model.parameters(), lr=learn_rate)
lr_opt = optimizer2
model_opt = optimizer2
# 调用官方动态学习率接口时使用2
lambda1 = lambda epoch : 0.92 ** (epoch // 4)
# optimizer = torch.optim.SGD(model.parameters(), lr=learn_rate)
scheduler = torch.optim.lr_scheduler.LambdaLR(lr_opt, lr_lambda=lambda1) #选定调整方法
2.3.2 编写训练函数
"""训练模型--编写训练函数"""
# 训练循环
def train(dataloader, model, loss_fn, optimizer):
size = len(dataloader.dataset) # 训练集的大小，一共60000张图片
num_batches = len(dataloader) # 批次数目，1875（60000/32）
train_loss, train_acc = 0, 0 # 初始化训练损失和正确率
for X, y in dataloader: # 加载数据加载器，得到里面的 X（图片数据）和 y（真实标签）
X, y = X.to(device), y.to(device) # 用于将数据存到显卡
# 计算预测误差
pred = model(X) # 网络输出
loss = loss_fn(pred, y) # 计算网络输出和真实值之间的差距，targets为真实值，计算二者差值即为损失
# 反向传播
optimizer.zero_grad() # 清空过往梯度
loss.backward() # 反向传播，计算当前梯度
optimizer.step() # 根据梯度更新网络参数
# 记录acc与loss
train_acc += (pred.argmax(1) == y).type(torch.float).sum().item()
train_loss += loss.item()
train_acc /= size
train_loss /= num_batches
return train_acc, train_loss
2.3.3 编写测试函数
"""训练模型--编写测试函数"""
# 测试函数和训练函数大致相同，但是由于不进行梯度下降对网络权重进行更新，所以不需要传入优化器
def test(dataloader, model, loss_fn):
size = len(dataloader.dataset) # 测试集的大小，一共10000张图片
num_batches = len(dataloader) # 批次数目，313（10000/32=312.5，向上取整）
test_loss, test_acc = 0, 0
# 当不进行训练时，停止梯度更新，节省计算内存消耗
with torch.no_grad(): # 测试时模型参数不用更新，所以 no_grad，整个模型参数正向推就ok，不反向更新参数
for imgs, target in dataloader:
imgs, target = imgs.to(device), target.to(device)
# 计算loss
target_pred = model(imgs)
loss = loss_fn(target_pred, target)
test_loss += loss.item()
test_acc += (target_pred.argmax(1) == target).type(torch.float).sum().item()#统计预测正确的个数
test_acc /= size
test_loss /= num_batches
return test_acc, test_loss
2.3.4 正式训练
"""训练模型--正式训练"""
epochs = 60
train_loss = []
train_acc = []
test_loss = []
test_acc = []
best_test_acc=0
for epoch in range(epochs):
milliseconds_t1 = int(time.time() * 1000)
# 更新学习率（使用自定义学习率时使用）
# adjust_learning_rate(lr_opt, epoch, learn_rate)
model.train()
epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, model_opt)
scheduler.step() # 更新学习率（调用官方动态学习率接口时使用）
model.eval()
epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)
train_acc.append(epoch_train_acc)
train_loss.append(epoch_train_loss)
test_acc.append(epoch_test_acc)
test_loss.append(epoch_test_loss)
# 获取当前的学习率
lr = lr_opt.state_dict()['param_groups'][0]['lr']
milliseconds_t2 = int(time.time() * 1000)
template = ('Epoch:{:2d}, duration:{}ms, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%，Test_loss:{:.3f}, Lr:{:.2E}')
if best_test_acc < epoch_test_acc:
best_test_acc = epoch_test_acc
#备份最好的模型
best_model = copy.deepcopy(model)
template = (
'Epoch:{:2d}, duration:{}ms, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%，Test_loss:{:.3f}, Lr:{:.2E},Update the best model')
print(
template.format(epoch + 1, milliseconds_t2-milliseconds_t1, epoch_train_acc * 100, epoch_train_loss, epoch_test_acc * 100, epoch_test_loss, lr))
# 保存最佳模型到文件中
PATH = './best_model.pth' # 保存的参数文件名
torch.save(model.state_dict(), PATH)
print('Done')
输出最高精度为Test_acc:95.6%
Epoch: 1, duration:6835ms, Train_acc:64.6%, Train_loss:0.868, Test_acc:16.0%，Test_loss:3.079, Lr:1.00E-04,Update the best model
Epoch: 2, duration:5852ms, Train_acc:65.2%, Train_loss:0.785, Test_acc:77.8%，Test_loss:0.597, Lr:1.00E-04,Update the best model
Epoch: 3, duration:5958ms, Train_acc:73.3%, Train_loss:0.595, Test_acc:76.4%，Test_loss:0.518, Lr:1.00E-04
...
Epoch:58, duration:6514ms, Train_acc:98.2%, Train_loss:0.052, Test_acc:92.9%，Test_loss:0.272, Lr:1.00E-04
Epoch:59, duration:6305ms, Train_acc:99.1%, Train_loss:0.042, Test_acc:92.4%，Test_loss:0.219, Lr:1.00E-04
Epoch:60, duration:6294ms, Train_acc:96.9%, Train_loss:0.143, Test_acc:92.0%，Test_loss:0.199, Lr:1.00E-04
2.4 结果可视化
"""训练模型--结果可视化"""
epochs_range = range(epochs)
plt.figure(figsize=(12, 3))
plt.subplot(1, 2, 1)
plt.plot(epochs_range, train_acc, label='Training Accuracy')
plt.plot(epochs_range, test_acc, label='Test Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')
plt.subplot(1, 2, 2)
plt.plot(epochs_range, train_loss, label='Training Loss')
plt.plot(epochs_range, test_loss, label='Test Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()
2.4 指定图片进行预测
def predict_one_image(image_path, model, transform, classes):
test_img = Image.open(image_path).convert('RGB')
plt.imshow(test_img) # 展示预测的图片
plt.show()
test_img = transform(test_img)
img = test_img.to(device).unsqueeze(0)
model.eval()
output = model(img)
_, pred = torch.max(output, 1)
pred_class = classes[pred]
print(f'预测结果是：{pred_class}')
# 将参数加载到model当中
model.load_state_dict(torch.load(PATH, map_location=device))
"""指定图片进行预测"""
classes = list(total_data.class_to_idx)
# 预测训练集中的某张照片
predict_one_image(image_path=str(Path(data_dir)/"Dark/dark (1).png"),
model=model,
transform=train_transforms,
classes=classes)
输出
预测结果是：cloudy
2.6 模型评估
"""模型评估"""
best_model.eval()
epoch_test_acc, epoch_test_loss = test(test_dl, best_model, loss_fn)
# 查看是否与我们记录的最高准确率一致
print(epoch_test_acc, epoch_test_loss)
输出
0.9555555555555556 0.15073023055447266
3 知识点详解
3.1 Yolov5四种网络模型
Yolov5官方代码中，给出的目标检测网络中一共有4个版本，分别是Yolov5s、Yolov5m、Yolov5l、Yolov5x四个模型。
学习一个新的算法，最好在脑海中对算法网络的整体架构有一个清晰的理解。
但比较尴尬的是，Yolov5代码中给出的网络文件是yaml格式，和原本Yolov3、Yolov4中的cfg不同。
因此无法用netron工具直接可视化的查看网络结构，造成有的同学不知道如何去学习这样的网络。
比如下载了Yolov5的四个pt格式的权重模型：
在《深入浅出Yolo系列之Yolov3&Yolov4核心基础知识完整讲解》中讲到，可以使用netron工具打开网络模型。
但因为netron对pt格式的文件兼容性并不好，直接使用netron工具打开，会发现，根本无法显示全部网络。
因此可以采用pt->onnx->netron的折中方式，先使用Yolov5代码中models/export.py脚本将pt文件转换为onnx格式，再用netron工具打开，这样就可以看全网络的整体架构了。
如果有同学对netron工具还不是很熟悉，这里还是放上安装netron工具的详解，如果需要安装，可以移步另一篇文章：《网络可视化工具netron详细安装流程》
如需下载Yolov5整体的4个网络pt文件及onnx文件，也可点击链接查看下载，便于直观的学习。
3.1.1 Yolov5网络结构图
安装好netron工具，就可以可视化的打开Yolov5的网络结构。
这里也和之前讲解Yolov3&Yolov4同样的方式，绘制了Yolov5s整体的网络结构图。配合netron的可视化网络结构查看，脑海中的架构会更加清晰。
本文也会以Yolov5s的网络结构为主线，讲解与其他三个模型（Yolov5m、Yolov5l、Yolov5x）的不同点，让大家对于Yolov5有一个深入浅出的了解。
3.1.2 网络结构可视化
将四种模型pt文件的转换成对应的onnx文件后，即可使用netron工具查看。
但是，有些同学可能不方便，使用脚本转换查看。
因此，也上传了每个网络结构图的图片，也可以直接点击查看。
虽然没有netron工具更直观，但是也可以学习了解。
3.1.2.1 Yolov5s网络结构
Yolov5s网络是Yolov5系列中深度最小，特征图的宽度最小的网络。后面的3种都是在此基础上不断加深，不断加宽。
上图绘制出的网络结构图也是Yolov5s的结构，大家也可直接点击查看，Yolov5s的网络结构可视化的图片。
3.1.2.2 Yolov5m网络结构
此处也放上netron打开的Yolov5m网络结构可视图，点击即可查看，后面第二版块会详细说明不同模型的不同点。
3.1.2.3 Yolov5l网络结构
此处也放上netronx打开的Yolov5l网络结构可视图，点击即可查看。
3.1.2.4 Yolov5x网络结构
此处也放上netronx打开的Yolov5x网络结构可视图，点击即可查看。
3.2 核心基础内容
3.2.1 Yolov3&Yolov4网络结构图
3.2.1.1 Yolov3网络结构图
Yolov3的网络结构是比较经典的one-stage结构，分为输入端、Backbone、Neck和Prediction四个部分。
在之前的《深入浅出Yolo系列之Yolov3&Yolov4核心基础知识完整讲解》中讲了很多，这里不多说，还是放上绘制的Yolov3的网络结构图。
3.2.1.2 Yolov4网络结构图
Yolov4在Yolov3的基础上进行了很多的创新。
比如输入端采用mosaic数据增强，
Backbone上采用了CSPDarknet53、Mish激活函数、Dropblock等方式，
Neck中采用了SPP、FPN+PAN的结构，
输出端则采用CIOU_Loss、DIOU_nms操作。
因此Yolov4对Yolov3的各个部分都进行了很多的整合创新，关于Yolov4详细的讲解还是可以参照之前写的《深入浅出Yolo系列之Yolov3&Yolov4核心基础知识完整讲解》，写的比较详细。
3.2.2 Yolov5核心基础内容
Yolov5的结构和Yolov4很相似，但也有一些不同，还是按照从整体到细节的方式，对每个板块进行讲解。
上图即Yolov5的网络结构图，可以看出，还是分为输入端、Backbone、Neck、Prediction四个部分。
大家可能对Yolov3比较熟悉，因此列举它和Yolov3的一些主要的不同点，并和Yolov4进行比较。
（1）输入端：Mosaic数据增强、自适应锚框计算、自适应图片缩放
（2）Backbone：Focus结构，CSP结构
（3）Neck：FPN+PAN结构
（4）Prediction：GIOU_Loss
下面丢上Yolov5作者的算法性能测试图：
Yolov5作者也是在COCO数据集上进行的测试，在之前的文章讲过，COCO数据集的小目标占比，因此最终的四种网络结构，性能上来说各有千秋。
Yolov5s网络最小，速度最少，AP精度也最低。但如果检测的以大目标为主，追求速度，倒也是个不错的选择。
其他的三种网络，在此基础上，不断加深加宽网络，AP精度也不断提升，但速度的消耗也在不断增加。
3.2.2.1 输入端
（1）Mosaic数据增强
Yolov5的输入端采用了和Yolov4一样的Mosaic数据增强的方式。
Mosaic数据增强提出的作者也是来自Yolov5团队的成员，不过，随机缩放、随机裁剪、随机排布的方式进行拼接，对于小目标的检测效果还是很不错的。
Mosaic数据增强的内容在之前《深入浅出Yolo系列之Yolov3&Yolov4核心基础知识完整讲解》文章中写的很详细，详情可以查看之前的内容。
（2） 自适应锚框计算
在Yolo算法中，针对不同的数据集，都会有初始设定长宽的锚框。
在网络训练中，网络在初始锚框的基础上输出预测框，进而和真实框groundtruth进行比对，计算两者差距，再反向更新，迭代网络参数。
因此初始锚框也是比较重要的一部分，比如Yolov5在Coco数据集上初始设定的锚框：
在Yolov3、Yolov4中，训练不同的数据集时，计算初始锚框的值是通过单独的程序运行的。
但Yolov5中将此功能嵌入到代码中，每次训练时，自适应的计算不同训练集中的最佳锚框值。
当然，如果觉得计算的锚框效果不是很好，也可以在代码中将自动计算锚框功能关闭。
控制的代码即train.py中上面一行代码，设置成False，每次训练时，不会自动计算。
（3）自适应图片缩放
在常用的目标检测算法中，不同的图片长宽都不相同，因此常用的方式是将原始图片统一缩放到一个标准尺寸，再送入检测网络中。
比如Yolo算法中常用416416，608608等尺寸，比如对下面800*600的图像进行缩放。
但Yolov5代码中对此进行了改进，也是Yolov5推理速度能够很快的一个不错的trick。
作者认为，在项目实际使用时，很多图片的长宽比不同，因此缩放填充后，两端的黑边大小都不同，而如果填充的比较多，则存在信息冗余，影响推理速度。
因此在Yolov5的代码中datasets.py的letterbox函数中进行了修改，对原始图像自适应的添加最少的黑边。
图像高度上两端的黑边变少了，在推理时，计算量也会减少，即目标检测速度会得到提升。
这种方式在之前github上Yolov3中也进行了讨论：https://github.com/ultralytics/yolov3/issues/232
在讨论中，通过这种简单的改进，推理速度得到了37%的提升，可以说效果很明显。
但是有的同学可能会有大大的问号？？如何进行计算的呢？按照Yolov5中的思路详细的讲解一下，在datasets.py的letterbox函数中也有详细的代码。
第一步：计算缩放比例
原始缩放尺寸是416*416，都除以原始图像的尺寸后，可以得到0.52，和0.69两个缩放系数，选择小的缩放系数。
第二步：计算缩放后的尺寸
原始图片的长宽都乘以最小的缩放系数0.52，宽变成了416，而高变成了312。
第三步：计算黑边填充数值
将416-312=104，得到原本需要填充的高度。再采用numpy中np.mod取余数的方式，得到8个像素，再除以2，即得到图片高度两端需要填充的数值。
此外，需要注意的是：
a.这里填充的是黑色，即（0，0，0），而Yolov5中填充的是灰色，即（114,114,114），都是一样的效果。
b.训练时没有采用缩减黑边的方式，还是采用传统填充的方式，即缩放到416*416大小。只是在测试，使用模型推理时，才采用缩减黑边的方式，提高目标检测，推理的速度。
c.为什么np.mod函数的后面用32？因为Yolov5的网络经过5次下采样，而2的5次方，等于32。所以至少要去掉32的倍数，再进行取余。
2.2.2 Backbone
（1）Focus结构
Focus结构，在Yolov3&Yolov4中并没有这个结构，其中比较关键是切片操作。
比如右图的切片示意图，443的图像切片后变成2212的特征图。
以Yolov5s的结构为例，原始6086083的图像输入Focus结构，采用切片操作，先变成30430412的特征图，再经过一次32个卷积核的卷积操作，最终变成30430432的特征图。
需要注意的是：Yolov5s的Focus结构最后使用了32个卷积核，而其他三种结构，使用的数量有所增加，先注意下，后面会讲解到四种结构的不同点。
（2）CSP结构
Yolov4网络结构中，借鉴了CSPNet的设计思路，在主干网络中设计了CSP结构。
Yolov5与Yolov4不同点在于，Yolov4中只有主干网络使用了CSP结构。
而Yolov5中设计了两种CSP结构，以Yolov5s网络为例，CSP1_X结构应用于Backbone主干网络，另一种CSP2_X结构则应用于Neck中。
这里关于CSPNet的内容，也可以查看之前的《深入浅出Yolo系列之Yolov3&Yolov4核心基础完整讲解》。
2.2.3 Neck
Yolov5现在的Neck和Yolov4中一样，都采用FPN+PAN的结构，但在Yolov5刚出来时，只使用了FPN结构，后面才增加了PAN结构，此外网络中其他部分也进行了调整。
因此，在Yolov5刚提出时，画的很多结构图，又都重新进行了调整。
这里关于FPN+PAN的结构，在《深入浅出Yolo系列之Yolov3&Yolov4核心基础知识完整讲解》中，讲的很多，大家应该都有理解。
但如上面CSPNet结构中讲到，Yolov5和Yolov4的不同点在于，
Yolov4的Neck结构中，采用的都是普通的卷积操作。而Yolov5的Neck结构中，采用借鉴CSPnet设计的CSP2结构，加强网络特征融合的能力。
2.2.4 输出端
（1）Bounding box损失函数
在《深入浅出Yolo系列之Yolov3&Yolov4核心基础知识完整讲解》中，详细的讲解了IOU_Loss，以及进化版的GIOU_Loss，DIOU_Loss，以及CIOU_Loss。
Yolov5中采用其中的CIOU_Loss做Bounding box的损失函数。
Yolov4中也采用CIOU_Loss作为目标Bounding box的损失。
（2）nms非极大值抑制
在目标检测的后处理过程中，针对很多目标框的筛选，通常需要nms操作。
因为CIOU_Loss中包含影响因子v，涉及groudtruth的信息，而测试推理时，是没有groundtruth的。
所以Yolov4在DIOU_Loss的基础上采用DIOU_nms的方式，而Yolov5中采用加权nms的方式。
可以看出，采用DIOU_nms，下方中间箭头的黄色部分，原本被遮挡的摩托车也可以检出。
在项目中，也采用了DIOU_nms的方式，在同样的参数情况下，将nms中IOU修改成DIOU_nms。对于一些遮挡重叠的目标，确实会有一些改进。
比如下面黄色箭头部分，原本两个人重叠的部分，在参数和普通的IOU_nms一致的情况下，修改成DIOU_nms，可以将两个目标检出。
虽然大多数状态下效果差不多，但在不增加计算成本的情况下，有稍微的改进也是好的。
2.3 Yolov5四种网络结构的不同点
Yolov5代码中的四种网络，和之前的Yolov3，Yolov4中的cfg文件不同，都是以yaml的形式来呈现。
而且四个文件的内容基本上都是一样的，只有最上方的depth_multiple和width_multiple两个参数不同，很多同学看的一脸懵逼，不知道只通过两个参数是如何控制四种结构的？
2.3.1 四种结构的参数
先取出Yolov5代码中，每个网络结构的两个参数：
（1）Yolov5s.yaml
（2）Yolov5m.yaml
（3）Yolov5l.yaml
（4）Yolov5x.yaml
四种结构就是通过上面的两个参数，来进行控制网络的深度和宽度。其中depth_multiple控制网络的深度，width_multiple控制网络的宽度。
2.3.2 Yolov5网络结构
四种结构的yaml文件中，下方的网络架构代码都是一样的。
为了便于讲解，将其中的Backbone部分提取出来，讲解如何控制网络的宽度和深度，yaml文件中的Head部分也是同样的原理。
在对网络结构进行解析时，yolo.py中下方的这一行代码将四种结构的depth_multiple，width_multiple提取出，赋值给gd，gw。后面主要对这gd，gw这两个参数进行讲解。
下面再细致的剖析下，看是如何控制每种结构，深度和宽度的。
2.3.3 Yolov5四种网络的深度
（1）不同网络的深度
在上图中，画了两种CSP结构，CSP1和CSP2，其中CSP1结构主要应用于Backbone中，CSP2结构主要应用于Neck中。
需要注意的是，四种网络结构中每个CSP结构的深度都是不同的。
a.以yolov5s为例，第一个CSP1中，使用了1个残差组件，因此是CSP1_1。而在Yolov5m中，则增加了网络的深度，在第一个CSP1中，使用了2个残差组件，因此是CSP1_2。
而Yolov5l中，同样的位置，则使用了3个残差组件，Yolov5x中，使用了4个残差组件。
其余的第二个CSP1和第三个CSP1也是同样的原理。
b.在第二种CSP2结构中也是同样的方式，以第一个CSP2结构为例，Yolov5s组件中使用了2×X=2×1=2个卷积，因为Ｘ=1，所以使用了1组卷积，因此是CSP2_1。
而Yolov5m中使用了2组，Yolov5l中使用了3组，Yolov5x中使用了4组。
其他的四个CSP2结构，也是同理。
Yolov5中，网络的不断加深，也在不断增加网络特征提取和特征融合的能力。
（2）控制深度的代码
控制四种网络结构的核心代码是yolo.py中下面的代码，存在两个变量，n和gd。
我们再将n和gd带入计算，看每种网络的变化结果。
（3）验证控制深度的有效性
我们选择最小的yolov5s.yaml和中间的yolov5l.yaml两个网络结构，将gd(depth_multiple)系数带入，看是否正确。
a. yolov5s.yaml
其中depth_multiple=0.33，即gd=0.33，而n则由上面红色框中的信息获得。
以上面网络框图中的第一个CSP1为例，即上面的第一个红色框。n等于第二个数值3。
而gd=0.33，带入（2）中的计算代码，结果n=1。因此第一个CSP1结构内只有1个残差组件，即CSP1_1。
第二个CSP1结构中，n等于第二个数值9，而gd=0.33，带入（2）中计算，结果n=3，因此第二个CSP1结构中有3个残差组件，即CSP1_3。
第三个CSP1结构也是同理，这里不多说。
b. yolov5l.xml
其中depth_multiple=1，即gd=1
和上面的计算方式相同，第一个CSP1结构中，n=3，带入代码中，结果n=3，因此为CSP1_3。
下面第二个CSP1和第三个CSP1结构都是同样的原理。
2.3.4 Yolov5四种网络的宽度
（1）不同网络的宽度:
如上图表格中所示，四种yolov5结构在不同阶段的卷积核的数量都是不一样的，因此也直接影响卷积后特征图的第三维度，即厚度，这里表示为网络的宽度。
a.以Yolov5s结构为例，第一个Focus结构中，最后卷积操作时，卷积核的数量是32个，因此经过Focus结构，特征图的大小变成30430432。
而yolov5m的Focus结构中的卷积操作使用了48个卷积核，因此Focus结构后的特征图变成30430448。yolov5l，yolov5x也是同样的原理。
b. 第二个卷积操作时，yolov5s使用了64个卷积核，因此得到的特征图是15215264。而yolov5m使用96个特征图，因此得到的特征图是15215296。yolov5l，yolov5x也是同理。
c. 后面三个卷积下采样操作也是同样的原理，这样不过多讲解。
四种不同结构的卷积核的数量不同，这也直接影响网络中，比如CSP1，CSP2等结构，以及各个普通卷积，卷积操作时的卷积核数量也同步在调整，影响整体网络的计算量。
大家最好可以将结构图和前面第一部分四个网络的特征图链接，对应查看，思路会更加清晰。
当然卷积核的数量越多，特征图的厚度，即宽度越宽，网络提取特征的学习能力也越强。
（2）控制宽度的代码
在yolov5的代码中，控制宽度的核心代码是yolo.py文件里面的这一行：
它所调用的子函数make_divisible的功能是：
（3）验证控制宽度的有效性
我们还是选择最小的yolov5s和中间的yolov5l两个网络结构，将width_multiple系数带入，看是否正确。
a. yolov5s.yaml
其中width_multiple=0.5，即gw=0.5。
以第一个卷积下采样为例，即Focus结构中下面的卷积操作。
按照上面Backbone的信息，我们知道Focus中，标准的c2=64，而gw=0.5，代入（2）中的计算公式，最后的结果=32。即Yolov5s的Focus结构中，卷积下采样操作的卷积核数量为32个。
再计算后面的第二个卷积下采样操作，标准c2的值=128，gw=0.5，代入（2）中公式，最后的结果=64，也是正确的。
b. yolov5l.yaml
其中width_multiple=1，即gw=1，而标准的c2=64，代入上面（2）的计算公式中，可以得到Yolov5l的Focus结构中，卷积下采样操作的卷积核的数量为64个，而第二个卷积下采样的卷积核数量是128个。
另外的三个卷积下采样操作，以及yolov5m，yolov5x结构也是同样的计算方式，这里不过多解释。
参考链接：
深入浅出Yolo系列之Yolov5核心基础知识完整讲解
总结
通过本文的学习，对YOLOv5网络结构有了一个初步的了解。
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
