VGG16网络介绍及代码撰写详解（总结1）

  可以从本人以前的文章中可以看出作者以前从事的是嵌入式控制方面相干的工作，是一个机器视觉小白，之以是开始入门机器视觉的学习只要是一个idea，想把机器视觉与控制相融合将来做一点小东西。废话不多说开始正题。

摘要：本文是介绍VGG16网络,个人对其的知识总结，网络设计的知识点，以及代码怎样撰写，基于pytorch编写代码。作为一个刚入门的小白怎么去学习别人的代码，一步一步的去明白每一行代码，怎么将网络设计变成代码，模仿大佬的代码去撰写。作为小白如有不足之处请品评指正哈。
机器视觉基础知识

在此之前，本人学习了机器视觉的基础知识，以下是本人学习时的链接希望对你有所资助。
https://fuhanghang.blog.csdn.net/article/details/135544761?fromshare=blogdetail&sharetype=blogdetail&sharerId=135544761&sharerefer=PC&sharesource=weixin_52531699&sharefrom=from_link
【盘算机视觉与深度学习 北京邮电大学 鲁鹏 清楚版合集（完备版）】 https://www.bilibili.com/video/BV1V54y1B7K3/?share_source=copy_web&vd_source=b25ae79b699fbc0a2f70ccb983f6b74a
VGG16

在网络设计之前需要明白什么是VGG16。
以下是我鉴戒的文章的参考链接：
https://blog.csdn.net/weixin_46676835/article/details/129582927?fromshare=blogdetail&sharetype=blogdetail&sharerId=129582927&sharerefer=PC&sharesource=weixin_52531699&sharefrom=from_link
https://blog.csdn.net/weixin_46676835/article/details/128730174?fromshare=blogdetail&sharetype=blogdetail&sharerId=128730174&sharerefer=PC&sharesource=weixin_52531699&sharefrom=from_link

VGG16是一个深度卷积神经网络，它在2014年由牛津大学视觉多少组（Visual Geometry Group）提出，并在ImageNet图像分类使掷中取得了显著的结果。以下是VGG16的一些关键特点：
1. 网络结构
层数: VGG16包罗16个主要的权重层，包罗13个卷积层和3个全连接层。
卷积层: VGG16使用小的3x3卷积核进行卷积操作，增长了网络的深度，同时保持了较少的参数数目。
池化层: 每隔几个卷积层后，会使用2x2的最大池化层（Max Pooling）来降低特征图的尺寸，并减少盘算量。
2. 激活函数
VGG网络普遍使用ReLU（Rectified Linear Unit）作为激活函数，增长了网络的非线性表达能力。
3. 输入和输出
输入: VGG16接受224x224像素的RGB图像作为输入。
输出: 最终的输出是一个1000维的向量，表现属于1000个种别的概率分布（针对ImageNet数据集）。
4. 特点与长处
深度: VGG16相对较深（16层），使其能够学习更复杂的特征。
简单性: 使用同一的小卷积核和堆叠结构，使得网络设计相对简单且易于明白。
预训练模子: VGG16在多种使掷中被广泛应用，并且可以使用预训练权重进行迁徙学习，以提高其他使命的性能。
5. 应用方面
VGG16被广泛应用于图像分类、物体检测、图像分割等盘算机视觉使命。由于其精良的表现，很多后续的研究和模子（例如，VGG19等）都是在此基础上进行改进的。

从图中可以看出，VGG16包罗16个主要的权重层，包罗13个卷积层和3个全连接层。
盘算过程

1）输入图像尺寸为224x224x3，经64个通道为3的3x3的卷积核，步长为1，padding=same填充，卷积两次，再经ReLU激活，输出的尺寸大小为224x224x64
2）经max pooling（最大化池化），滤波器为2x2，步长为2，图像尺寸减半，池化后的尺寸变为112x112x64
3）经128个3x3的卷积核，两次卷积，ReLU激活，尺寸变为112x112x128
4）max pooling池化，尺寸变为56x56x128
5）经256个3x3的卷积核，三次卷积，ReLU激活，尺寸变为56x56x256
6）max pooling池化，尺寸变为28x28x256
7）经512个3x3的卷积核，三次卷积，ReLU激活，尺寸变为28x28x512
8）max pooling池化，尺寸变为14x14x512
9）经512个3x3的卷积核，三次卷积，ReLU，尺寸变为14x14x512
10）max pooling池化，尺寸变为7x7x512
11）然后Flatten()，将数据拉平成向量，变成一维512 ×7 ×7=25088。
11）再经过两层1x1x4096，一层1x1x1000的全连接层（共三层），经ReLU激活
12）末了通过softmax输出1000个预测效果，这是官方的（最终本人输出3种）
软件代码构思

有了以上理论基础后，开始构建代码思路，整体构建思路如下图所示，写代码之前肯定要构思好大抵思路，代码永远是为你思路框架服务的。

训练部分代码撰写

1.参数初始化
这一部分的代码的作用是，起首是关键参数以及头文件的初始化，再然后就是读取jpg文件，以及txt文件的内容，将其分为3类，蚂蚁，蜜蜂，狗，后续品种可以本身添加，jpg，txt训练数据多少都可以由本身添加，但是文件的命名格式必须为1.jpg，1.txt，2.jpg，2.txt才能读取文件。
（1）头文件初始化

1. import os
2. import parser
3. import time
4. import numpy as np
5. import torch
6. import torchvision.transforms as transforms
7. import PIL
8. from PIL import Image
9. from scipy.stats import norm
10. from torch import nn
11. from torch.utils.data import Dataset, random_split, DataLoader, ConcatDataset
12. import torchvision.datasets
13. from torch import nn
14. from torch.nn import MaxPool2d, Flatten
16. import argparse
17. from pathlib import Path

复制代码

import os：用于读取文件路径。
import time：用于时间相干的功能，本文用其盘算训练时间。
import torchvision.transforms as transforms：用于图像处置惩罚和转换的模块，常用于数据预处置惩罚。
import torchvision.datasets：提供了常用数据集的接口，例如MNIST、CIFAR等。
from PIL import Image：Pillow库，用于图像的打开、处置惩罚和保存。
from torch.nn import MaxPool2d, Flatten：导入特定的层，MaxPool2d用于进行二维最大池化，Flatten将多维输入展平为一维。
from torch.utils.data import Dataset, random_split, DataLoader, ConcatDataset：用于自界说数据集和数据加载器，方便批量处置惩罚数据。
import argparse：用于处置惩罚命令行参数，使得脚本可以接受用户输入的参数。
from pathlib import Path：提供高级路径操作功能，方便文件系统的操作。
（2）参数界说函数
用parse_opt()这个函数主要是见过很多大佬的文章都是用这个函数转义。作为小白像较为官方的标准化参数结构学习。

1. def parse_opt():
2.     parser = argparse.ArgumentParser()  # 创建 ArgumentParser 对象
3.     parser.add_argument('--epochs', type=int, default=5, help='total training epochs')  # 添加参数
4.     parser.add_argument('--batch_size', type=int, default=16, help='size of each batch')  # 添加批次大小参数
5.     parser.add_argument('--learning_rate', type=int, default=0.03, help='size of learning_rate')  # 添加批次大小参数
6.     #--device "cuda:0,cuda:1" 启用多个设备
7.     parser.add_argument('--device', default='cuda:0', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')  #--device cuda:1
8.     # 解析参数
9.     opt = parser.parse_args()
10.     return opt
12. opt = parse_opt()  # 调用解析函数
13. epochs = opt.epochs              # 训练的轮数
14. batch_size = opt.batch_size      # 每个批次的样本数量
15. learning_rate = opt.learning_rate
16. device = torch.device(opt.device)

复制代码

（3）界说文件处置惩罚类
这部分代码的编写主要是要实现一个功能，怎样把1.jpg，1.txt，2.jpg，2.txt…文件读取处置惩罚，并将txt文件的内容进行处置惩罚实现分类。

1. class CustomDataset(Dataset):
2.     def __init__(self, img_dir, label_dir, transform=None):
3.         self.img_dir = img_dir
4.         self.label_dir = label_dir
5.         self.transform = transform
6.         self.img_labels = self.load_labels()
8.     def load_labels(self):
9.         label_map = {'ants': 0, 'bees': 1,'dogs': 2}    #字典label_map 来定义标签与数字之间的映射关系
10.         labels = []                                     #创建一个空列表 labels，用来存储从文件中读取到的标签的数字编码
11.         for label_file in os.listdir(self.label_dir):
12.             with open(os.path.join(self.label_dir, label_file), 'r') as f:  #对于每个标签文件，使用 open() 打开文件并读取第一行内容readline()
13.                 line = f.readline().strip()         #strip() 方法用于去掉行首和行尾的空白字符（包括换行符）
14.                 #从label_map 中获取当前行的标签对应的数字编码。如果当前行的内容不在 label_map 中，则返回-1
15.                 labels.append(label_map.get(line, -1))
16.         return labels
18.     def __len__(self):
19.         return len(self.img_labels)
21.     def __getitem__(self, idx):
22.         #使用 os.path.join 将图像目录路径 (self.img_dir) 和图像文件名拼接起来。文件名格式为 idx + 1（即从1开始计数），加上 .jpg 后缀。
23.         #例如，如果idx为0，则img_path会是 D:\\Pycharm\\Pytorch_test\\数据集\\练手数据集\\train\\ants_image\\1.jpg
24.         img_path = os.path.join(self.img_dir, str(idx+1) + '.jpg')
25.         image = Image.open(img_path).convert('RGB')  #打开指定路径的图像文件，并将其转换为 RGB 模式。
26.         label = self.img_labels[idx]   #列表中获取当前图像的标签，idx 是当前图像的索引
28.         if self.transform:   #transform变量是在CustomDataset中最终调用的transforms.Compose实现
29.             image = self.transform(image)
31.         return image, label

复制代码

使用字典 label_map 来界说标签与数字之间的映射关系：‘ants’ 对应 0；‘bees’ 对应 1；‘dogs’ 对应 2。对于每个标签文件，使用 open() 打开文件并读取第一行内容（readline()）。strip() 方法用于去掉行首和行尾的空白字符（包罗换行符）。使用 label_map.get(line, -1) 从 label_map 中获取当前行的标签对应的数字编码。如果当前行的内容不在 label_map 中，则返回 -1。本人其时在这就犯了一个错误。可以从调试的框中看出，我有一个txt文件的内容并不是dogs致使其返回的值为-1，出现这个问题的缘故原由是本人txt文件中dogs没有保存，以是切记肯定要保存文件如果本身训练模子自建数据集的话。很多内容方面，解释写的很清楚，作者就不细讲了。

订正错误后的效果：

（4）数据集图片输入
代码需要实现一个图像大小设置功能，由于输入图像大小不确定需要将其设置成224×224大小图片，满足输入网络图像大小的设定。

1. # 定义转换，包括调整大小
2. transform = transforms.Compose([
3.     transforms.Resize((224, 224)),  # 调整为 224x224 大小
4.     transforms.ToTensor(),          # 转换为 Tensor
5.     torchvision.transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
6.     # 可以添加其他转换，例如归一化等
7. ])
9. # 初始化数据集
10. ants_data = CustomDataset(
11.     img_dir='D:\\Pycharm\\Pytorch_test\\数据集\\练手数据集\\train\\ants_image',
12.     label_dir='D:\\Pycharm\\Pytorch_test\\数据集\\练手数据集\\train\\ants_label',
13.     transform=transform
14. )
16. bees_data = CustomDataset(
17.     img_dir='D:\\Pycharm\\Pytorch_test\\数据集\\练手数据集\\train\\bees_image',
18.     label_dir='D:\\Pycharm\\Pytorch_test\\数据集\\练手数据集\\train\\bees_label',
19.     transform=transform
20. )
22. dogs_data = CustomDataset(
23.     img_dir='D:\\Pycharm\\Pytorch_test\\数据集\\练手数据集\\train\\dogs_image',
24.     label_dir='D:\\Pycharm\\Pytorch_test\\数据集\\练手数据集\\train\\dogs_label',
25.     transform=transform
26. )

复制代码

transform 是通过 transforms.Compose 创建的一个组合转换对象。这个对象整合了多个图像预处置惩罚步骤，包罗调整大小、转换为张量，以及归一化。调整大小: 将图像调整为 224x224 像素。转换为 Tensor: 将 PIL 图像或 NumPy 数组转换为 PyTorch 张量。归一化: 根据给定的均值和标准差对张量进行归一化处置惩罚，使得数据分布更得当神经网络训练。归一化是VGG16网络的要求，但是本人发现没有也行，但所提供的代码为按照官方要求编写的。
ants_data 是 CustomDataset 类的一个实例，用于加载蚂蚁图像数据集。
img_dir 指定了存放图像文件的目次。
label_dir 指定了存放标签文件的目次。
transform 是应用于图像的转换操作（如缩放、裁剪、归一化等），即在加载图像时对其进行预处置惩罚。也就是调用transforms.Compose 。
从代码中也可以看出，实现的效果是读取图像读取标签然后通过transform将其变成224x224。

训练图片标签所在如图所示。
2.将数据集总和并随机打乱并分成训练集测试集
这段代码的作用是将我所读取的数据ants_data+bees_data+dogs_data总和起来，然后随机打乱，分割出训练集测试集分别是7：3。

1. # 合并数据集
2. total_data = ants_data+bees_data
3. total_data = total_data+dogs_data
4. # 计算训练集和验证集的大小
5. total_size = len(total_data)
6. train_size = int(0.7 * total_size)  # 70%
7. val_size = total_size - train_size    # 30%
9. train_data_size = train_size
10. val_data_size = val_size
12. print("训练集长度：{}".format(train_data_size))
13. print("测试集长度：{}".format(val_data_size))
14. # 随机分割数据集
15. train_data, val_data = random_split(total_data, [train_size, val_size])
17. # 创建 DataLoader，分成小批量（batches），以便于进行训练和验证
18. train_dataloader = DataLoader(train_data, batch_size, shuffle=True) #shuffle=True可以随机打乱数据
19. val_dataloader = DataLoader(val_data, batch_size, shuffle=False)
20. # 打印数据集大小在这里插入图片描述
22. print("训练集大小：{}".format(len(train_data)))
23. print("验证集大小：{}".format(len(val_data)))

复制代码

从调试图中可知ants_data = 110,bees_data = 70,dogs_data = 120,total_data = 300，这也是我训练时提供的图片数目，标太多太累了。
3.创建网络模子
这部分是根据上图的vgg16网络结构搭建的。具体代码如下，本人写法为小白写法应该普通易懂。

1. class VGG16(nn.Module):
2.     def __init__(self):
3.         super(VGG16, self).__init__()
4.         self.model = nn.Sequential(  # 构建子类，可以减少foward代码撰写
5.             nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3, stride=1, padding=1),
6.             nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, stride=1, padding=1),
7.             nn.MaxPool2d(kernel_size=2, stride=2), #最大池化将224变成112
8.             nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, stride=1, padding=1),
9.             nn.Conv2d(in_channels=128, out_channels=128, kernel_size=3, stride=1, padding=1),
10.             nn.MaxPool2d(kernel_size=2, stride=2), # 56x56
11.             nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, stride=1, padding=1),
12.             nn.Conv2d(in_channels=256, out_channels=256, kernel_size=3, stride=1, padding=1),
13.             nn.Conv2d(in_channels=256, out_channels=256, kernel_size=3, stride=1, padding=1),
14.             nn.MaxPool2d(kernel_size=2, stride=2),  # 28x28
15.             nn.Conv2d(in_channels=256, out_channels=512, kernel_size=3, stride=1, padding=1),
16.             nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=1, padding=1),
17.             nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=1, padding=1),
18.             nn.MaxPool2d(kernel_size=2, stride=2), # 14x14
19.             nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=1, padding=1),
20.             nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=1, padding=1),
21.             nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=1, padding=1),
22.             nn.MaxPool2d(kernel_size=2, stride=2),  # 7x7
23.         )
24.         # 使用AdaptiveAvgPool2d来确保输出为固定大小
25.         self.avgpool = nn.AdaptiveAvgPool2d((7, 7))
27.         # 全连接层
28.         self.fc1 = nn.Linear(in_features=512 * 7 * 7, out_features=4096)
29.         self.fc2 = nn.Linear(in_features=4096, out_features=4096)
30.         self.fc3 = nn.Linear(in_features=4096, out_features=3)
32.         self.relu = nn.ReLU()
33.         self.dropout = nn.Dropout(0.3)
35.     def forward(self, x):
36.         x = self.model(x)
37.         x = self.avgpool(x)  # 使用自适应平均池化
38.         x = x.view(x.size(0), -1)  # 拉平操作,(batch_size, num_features) 也就是（8，25088） 512*7*7 = 25088
39.         x = self.relu(self.fc1(x))
40.         x = self.dropout(x)
41.         x = self.relu(self.fc2(x))
42.         x = self.dropout(x)
43.         x = self.fc3(x)
44.         return x

复制代码

1. x = self.avgpool(x) 自适应平均池化，将输入特征图（x）的空间维度降低到固定大小。

复制代码

1. x = x.view(x.size(0), -1)  这行代码将输出张量 x 的形状变为 (batch_size, num_features)，
2. 其中 batch_size 是当前批次的样本数量，num_features 是特征的总数。这一步是为了将多维张量转换为二维张量，
3. 以便进入全连接层进行分类。

复制代码

4.训练加测试
这部分得先明白工作步骤再写代码。1.训练集训练调用VGG16网络结构，丧失函数构建，随机梯度下降，优化训练 2.测试集测试，设置为评估模式，调用VGG16网络结构，丧失函数构建，丧失盘算。3.输出训练丧失，测试丧失，正确率。这部分是机器视觉基础概念知识。

1. def train():
2.     My_VGG16 = VGG16()              #调用类
3.     My_VGG16 = My_VGG16.to(device)
5.     # (1).损失函数构建
6.     loss_fn = nn.CrossEntropyLoss()  #计算预测值与真实标签之间的差异
7.     loss_fn = loss_fn.to(device)     #将模型和数据都放在同一个设备上，GPU
9.     # (2).优化器
10.     # #随机梯度下降（Stochastic Gradient Descent）优化器的一种实现。SGD 是一种常见的优化算法
11.     optimizer = torch.optim.SGD(My_VGG16.parameters(), lr=learning_rate)
13.     # 用于存储损失和准确率
14.     train_losses = []
15.     val_losses = []
16.     accuracies = []
18.     for i in range(epochs):
19.         loss_temp = 0  # 临时变量
20.         print("--------第{}轮训练开始--------".format(i + 1))
22.         # 训练阶段
23.         My_VGG16.train()  # 设置为训练模式
24.         #data有两个部分分别是(8,3,224,224),(8,) 一定要注意顺序
25.         for data in train_dataloader:
26.             imgs, targets = data
27.             imgs = imgs.to(device)
28.             targets = targets.to(device)
29.             #outputs = tensor（8，3）
30.             outputs = My_VGG16(imgs)
31.             loss = loss_fn(outputs, targets)
33.             # 优化器优化模型
34.             optimizer.zero_grad()  # 梯度清零
35.             loss.backward()  # 反向传播
36.             optimizer.step()  # 梯度更新
38.             loss_temp += loss.item()
40.         # 记录训练损失
41.         train_losses.append(loss_temp / len(train_dataloader))
43.         # 测试阶段
44.         My_VGG16.eval()  # 设置为评估模式
45.         total_test_loss = 0
46.         total_accuracy = 0
47.         with torch.no_grad():
48.             for data in val_dataloader:
49.                 imgs, targets = data
50.                 imgs = imgs.to(device)
51.                 targets = targets.to(device)
52.                 outputs = My_VGG16(imgs)
53.                 loss = loss_fn(outputs, targets)
55.                 total_test_loss += loss.item()
56.                 #找到每个样本的预测类别，然后与真实标签进行比较
57.                 accuracy = (outputs.argmax(1) == targets).sum().item()  # 使用.item()将Tensor转换为Python数值
58.                 total_accuracy += accuracy   #计算正确预测的数量并累加到 total_accuracy

复制代码

1. imgs, targets = data这段代码

复制代码

可以从图中看出data有两个部分分别是(8,3,224,224),(8,) 肯定要留意序次分别对应的就是imgs，targets

1. outputs = My_VGG16(imgs)  outputs = tensor（8，3）

复制代码

outputs单纯的就是输出品种效果，8是因为我的batch_size = 8，输入的是8张图片。
5.保存数据至.pth文件并画图
这部分代码的编写需要实现的是，将训练的权值保存至.pth文件中，并在窗口中显示训练时的时间，loss，正确率输出思量到train_loss为list：5，以是直接使用循环的打印输出效果。

1.   # 记录验证损失和准确率
2.         val_losses.append(total_test_loss / len(val_dataloader))
3.         accuracies.append(total_accuracy / val_data_size)
5.         print("整体测试集上的正确率:{}".format(total_accuracy / val_data_size))
6.         print("整体测试集上的Loss：{}".format(total_test_loss))
8.     # 保存模型
9.     torch.save(My_VGG16, "vgg16_{}.pth".format(2))
10.     torch.save(My_VGG16.state_dict(), "vgg16_dict_{}.txt".format(2))
11.     print("模型已保存")
13.     # 绘制损失和准确率曲线
14.     epochs_range = range(1, epochs + 1)
16.     plt.figure(figsize=(12, 5))  #创建一个新的图形窗口，设置图形的大小
18.     # 训练和验证损失
19.     plt.subplot(1, 2, 1)  #第一个图像框
20.     plt.plot(epochs_range, train_losses, label='Training Loss')
21.     #train_losses=[1.0952595781396937, 1.085733965591148, 1.07982603708903, 1.0776626953372248, 1.0816458507820412]
22.     plt.plot(epochs_range, val_losses, label='Validation Loss')
23.     plt.title('Loss vs Epochs')
24.     plt.xlabel('Epochs')
25.     plt.ylabel('Loss')
26.     plt.legend()
28.     # 准确率
29.     plt.subplot(1, 2, 2)
30.     plt.plot(epochs_range, accuracies, label='Validation Accuracy')
31.     plt.title('Accuracy vs Epochs')
32.     plt.xlabel('Epochs')
33.     plt.ylabel('Accuracy')
34.     plt.legend()
36.     plt.tight_layout()
37.     plt.show()
39. if __name__ == '__main__':
40.     parse_opt()
41.     train()
42.     # 测试模型
43.     # model = VGG16()
44.     # sample_input = torch.randn(1, 3, 224, 224)  # Batch size 为 1
45.     # output = model(sample_input)
46.     # print("Final output shape:", output.shape)  # 应输出 [1, 3]

复制代码

代码讲解，解释很具体，不做细数。

输出图片效果，这是只训练了5次的网络，可以看到训练效果是不理想的。
以上就是训练集代码及讲解。
训练整体代码：

1. #VGG_16训练网络模子，第一代测试代码，主要功能如下#辨认3类蚂蚁，蜜蜂，狗，可恣意添加，文件名为1.jpg,1.txt,内容ants#2代是在一代的基础上添加了图像显示，标准化参数设计方面import os
2. import parser
3. import time
4. import numpy as np
5. import torch
6. import torchvision.transforms as transforms
7. import PIL
8. from PIL import Image
9. from scipy.stats import norm
10. from torch import nn
11. from torch.utils.data import Dataset, random_split, DataLoader, ConcatDataset
12. import torchvision.datasets
13. from torch import nn
14. from torch.nn import MaxPool2d, Flatten
16. import argparse
17. from pathlib import Path
18. # ------------------------------1.初始化，标准参数初始化-------------------------------def parse_opt():    parser = argparse.ArgumentParser()  # 创建 ArgumentParser 对象    parser.add_argument('--epochs', type=int, default=5, help='total training epochs')  # 添加参数    parser.add_argument('--batch_size', type=int, default=8, help='size of each batch')  # 添加批次大小参数    parser.add_argument('--learning_rate', type=int, default=0.03, help='size of learning_rate')  # 添加批次大小参数    #--device "cuda:0,cuda:1" 启用多个设备    parser.add_argument('--device', default='cuda:0', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')  #--device cuda:1    # 剖析参数    opt = parser.parse_args()    return optopt = parse_opt()  # 调用剖析函数epochs = opt.epochs              # 训练的轮数batch_size = opt.batch_size      # 每个批次的样本数目learning_rate = opt.learning_ratedevice = torch.device(opt.device)class CustomDataset(Dataset):
19.     def __init__(self, img_dir, label_dir, transform=None):
20.         self.img_dir = img_dir
21.         self.label_dir = label_dir
22.         self.transform = transform
23.         self.img_labels = self.load_labels()
25.     def load_labels(self):
26.         label_map = {'ants': 0, 'bees': 1,'dogs': 2}    #字典label_map 来定义标签与数字之间的映射关系
27.         labels = []                                     #创建一个空列表 labels，用来存储从文件中读取到的标签的数字编码
28.         for label_file in os.listdir(self.label_dir):
29.             with open(os.path.join(self.label_dir, label_file), 'r') as f:  #对于每个标签文件，使用 open() 打开文件并读取第一行内容readline()
30.                 line = f.readline().strip()         #strip() 方法用于去掉行首和行尾的空白字符（包括换行符）
31.                 #从label_map 中获取当前行的标签对应的数字编码。如果当前行的内容不在 label_map 中，则返回-1
32.                 labels.append(label_map.get(line, -1))
33.         return labels
35.     def __len__(self):
36.         return len(self.img_labels)
38.     def __getitem__(self, idx):
39.         #使用 os.path.join 将图像目录路径 (self.img_dir) 和图像文件名拼接起来。文件名格式为 idx + 1（即从1开始计数），加上 .jpg 后缀。
40.         #例如，如果idx为0，则img_path会是 D:\\Pycharm\\Pytorch_test\\数据集\\练手数据集\\train\\ants_image\\1.jpg
41.         img_path = os.path.join(self.img_dir, str(idx+1) + '.jpg')
42.         image = Image.open(img_path).convert('RGB')  #打开指定路径的图像文件，并将其转换为 RGB 模式。
43.         label = self.img_labels[idx]   #列表中获取当前图像的标签，idx 是当前图像的索引
45.         if self.transform:   #transform变量是在CustomDataset中最终调用的transforms.Compose实现
46.             image = self.transform(image)
48.         return image, label
49. # 定义转换，包括调整大小
50. transform = transforms.Compose([
51.     transforms.Resize((224, 224)),  # 调整为 224x224 大小
52.     transforms.ToTensor(),          # 转换为 Tensor
53.     torchvision.transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
54.     # 可以添加其他转换，例如归一化等
55. ])
57. # 初始化数据集
58. ants_data = CustomDataset(
59.     img_dir='D:\\Pycharm\\Pytorch_test\\数据集\\练手数据集\\train\\ants_image',
60.     label_dir='D:\\Pycharm\\Pytorch_test\\数据集\\练手数据集\\train\\ants_label',
61.     transform=transform
62. )
64. bees_data = CustomDataset(
65.     img_dir='D:\\Pycharm\\Pytorch_test\\数据集\\练手数据集\\train\\bees_image',
66.     label_dir='D:\\Pycharm\\Pytorch_test\\数据集\\练手数据集\\train\\bees_label',
67.     transform=transform
68. )
70. dogs_data = CustomDataset(
71.     img_dir='D:\\Pycharm\\Pytorch_test\\数据集\\练手数据集\\train\\dogs_image',
72.     label_dir='D:\\Pycharm\\Pytorch_test\\数据集\\练手数据集\\train\\dogs_label',
73.     transform=transform
74. )
75. #-----------------------2.将数据集总和并随机打乱并分成训练集测试集-------------------# 归并数据集total_data = ants_data+bees_datatotal_data = total_data+dogs_data# 盘算训练集和验证集的大小total_size = len(total_data)train_size = int(0.7 * total_size)  # 70%val_size = total_size - train_size    # 30%train_data_size = train_sizeval_data_size = val_sizeprint("训练集长度：{}".format(train_data_size))print("测试集长度：{}".format(val_data_size))# 随机分割数据集train_data, val_data = random_split(total_data, [train_size, val_size])# 创建 DataLoader，分成小批量（batches），以便于进行训练和验证train_dataloader = DataLoader(train_data, batch_size, shuffle=True) #shuffle=True可以随机打乱数据val_dataloader = DataLoader(val_data, batch_size, shuffle=False)# 打印数据集大小print("训练集大小：{}".format(len(train_data)))print("验证集大小：{}".format(len(val_data)))#----------------------------3.创建网络模子--------------------------------class VGG16(nn.Module):
76.     def __init__(self):
77.         super(VGG16, self).__init__()
78.         self.model = nn.Sequential(  # 构建子类，可以减少foward代码撰写
79.             nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3, stride=1, padding=1),
80.             nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, stride=1, padding=1),
81.             nn.MaxPool2d(kernel_size=2, stride=2), #最大池化将224变成112
82.             nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, stride=1, padding=1),
83.             nn.Conv2d(in_channels=128, out_channels=128, kernel_size=3, stride=1, padding=1),
84.             nn.MaxPool2d(kernel_size=2, stride=2), # 56x56
85.             nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, stride=1, padding=1),
86.             nn.Conv2d(in_channels=256, out_channels=256, kernel_size=3, stride=1, padding=1),
87.             nn.Conv2d(in_channels=256, out_channels=256, kernel_size=3, stride=1, padding=1),
88.             nn.MaxPool2d(kernel_size=2, stride=2),  # 28x28
89.             nn.Conv2d(in_channels=256, out_channels=512, kernel_size=3, stride=1, padding=1),
90.             nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=1, padding=1),
91.             nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=1, padding=1),
92.             nn.MaxPool2d(kernel_size=2, stride=2), # 14x14
93.             nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=1, padding=1),
94.             nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=1, padding=1),
95.             nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=1, padding=1),
96.             nn.MaxPool2d(kernel_size=2, stride=2),  # 7x7
97.         )
98.         # 使用AdaptiveAvgPool2d来确保输出为固定大小
99.         self.avgpool = nn.AdaptiveAvgPool2d((7, 7))
101.         # 全连接层
102.         self.fc1 = nn.Linear(in_features=512 * 7 * 7, out_features=4096)
103.         self.fc2 = nn.Linear(in_features=4096, out_features=4096)
104.         self.fc3 = nn.Linear(in_features=4096, out_features=3)
106.         self.relu = nn.ReLU()
107.         self.dropout = nn.Dropout(0.3)
109.     def forward(self, x):
110.         x = self.model(x)
111.         x = self.avgpool(x)  # 使用自适应平均池化
112.         x = x.view(x.size(0), -1)  # 拉平操作,(batch_size, num_features) 也就是（8，25088） 512*7*7 = 25088
113.         x = self.relu(self.fc1(x))
114.         x = self.dropout(x)
115.         x = self.relu(self.fc2(x))
116.         x = self.dropout(x)
117.         x = self.fc3(x)
118.         return x
119. #------------------------------------4.训练加测试-----------------------import numpy as npimport matplotlibmatplotlib.use('TkAgg')  # 大概尝试 'Qt5Agg'，有这行代码会多一个弹窗显示import matplotlib.pyplot as pltimport torch.nn as nndef train():
120.     My_VGG16 = VGG16()              #调用类
121.     My_VGG16 = My_VGG16.to(device)
123.     # (1).损失函数构建
124.     loss_fn = nn.CrossEntropyLoss()  #计算预测值与真实标签之间的差异
125.     loss_fn = loss_fn.to(device)     #将模型和数据都放在同一个设备上，GPU
127.     # (2).优化器
128.     # #随机梯度下降（Stochastic Gradient Descent）优化器的一种实现。SGD 是一种常见的优化算法
129.     optimizer = torch.optim.SGD(My_VGG16.parameters(), lr=learning_rate)
131.     # 用于存储损失和准确率
132.     train_losses = []
133.     val_losses = []
134.     accuracies = []
136.     for i in range(epochs):
137.         loss_temp = 0  # 临时变量
138.         print("--------第{}轮训练开始--------".format(i + 1))
140.         # 训练阶段
141.         My_VGG16.train()  # 设置为训练模式
142.         #data有两个部分分别是(8,3,224,224),(8,) 一定要注意顺序
143.         for data in train_dataloader:
144.             imgs, targets = data
145.             imgs = imgs.to(device)
146.             targets = targets.to(device)
147.             #outputs = tensor（8，3）
148.             outputs = My_VGG16(imgs)
149.             loss = loss_fn(outputs, targets)
151.             # 优化器优化模型
152.             optimizer.zero_grad()  # 梯度清零
153.             loss.backward()  # 反向传播
154.             optimizer.step()  # 梯度更新
156.             loss_temp += loss.item()
158.         # 记录训练损失
159.         train_losses.append(loss_temp / len(train_dataloader))
161.         # 测试阶段
162.         My_VGG16.eval()  # 设置为评估模式
163.         total_test_loss = 0
164.         total_accuracy = 0
165.         with torch.no_grad():
166.             for data in val_dataloader:
167.                 imgs, targets = data
168.                 imgs = imgs.to(device)
169.                 targets = targets.to(device)
170.                 outputs = My_VGG16(imgs)
171.                 loss = loss_fn(outputs, targets)
173.                 total_test_loss += loss.item()
174.                 #找到每个样本的预测类别，然后与真实标签进行比较
175.                 accuracy = (outputs.argmax(1) == targets).sum().item()  # 使用.item()将Tensor转换为Python数值
176.                 total_accuracy += accuracy   #计算正确预测的数量并累加到 total_accuracy
177. #-----------------------5.保存数据至.pth文件并画图---------------------------------------------------        # 记录验证损失和准确率
178.         val_losses.append(total_test_loss / len(val_dataloader))
179.         accuracies.append(total_accuracy / val_data_size)
181.         print("整体测试集上的正确率:{}".format(total_accuracy / val_data_size))
182.         print("整体测试集上的Loss：{}".format(total_test_loss))
184.     # 保存模型
185.     torch.save(My_VGG16, "vgg16_{}.pth".format(2))
186.     torch.save(My_VGG16.state_dict(), "vgg16_dict_{}.txt".format(2))
187.     print("模型已保存")
189.     # 绘制损失和准确率曲线
190.     epochs_range = range(1, epochs + 1)
192.     plt.figure(figsize=(12, 5))  #创建一个新的图形窗口，设置图形的大小
194.     # 训练和验证损失
195.     plt.subplot(1, 2, 1)  #第一个图像框
196.     plt.plot(epochs_range, train_losses, label='Training Loss')
197.     #train_losses=[1.0952595781396937, 1.085733965591148, 1.07982603708903, 1.0776626953372248, 1.0816458507820412]
198.     plt.plot(epochs_range, val_losses, label='Validation Loss')
199.     plt.title('Loss vs Epochs')
200.     plt.xlabel('Epochs')
201.     plt.ylabel('Loss')
202.     plt.legend()
204.     # 准确率
205.     plt.subplot(1, 2, 2)
206.     plt.plot(epochs_range, accuracies, label='Validation Accuracy')
207.     plt.title('Accuracy vs Epochs')
208.     plt.xlabel('Epochs')
209.     plt.ylabel('Accuracy')
210.     plt.legend()
212.     plt.tight_layout()
213.     plt.show()
215. if __name__ == '__main__':
216.     parse_opt()
217.     train()
218.     # 测试模型
219.     # model = VGG16()
220.     # sample_input = torch.randn(1, 3, 224, 224)  # Batch size 为 1
221.     # output = model(sample_input)
222.     # print("Final output shape:", output.shape)  # 应输出 [1, 3]

复制代码

留意本人的训练是用的gpu，不推荐用cpu跑代码训练。
检测部分代码撰写

这一部分的代码主要实现的是输入恣意大小的图片，预测出它的种类。
1.导入头文件参数初始化
导入头文件，参数标准化后，读取图片，并通过transform实现图片输入格式的设置。

2. import torch
3. import torchvision
4. from PIL import Image
5. from torch import nn
6. from torch.nn import MaxPool2d
7. import argparse
8. from pathlib import Path
10. #--------------------------1.参数数据初始化-----------------------------------
11. def parse_opt():
12.     parser = argparse.ArgumentParser()  # 创建 ArgumentParser 对象
13.     parser.add_argument('--Dropout_Val', type=int, default=0.4, help='Dropout_Val number')  # 添加参数
14.     #--device "cuda:0,cuda:1" 启用多个设备
15.     parser.add_argument('--device', default='cuda:0', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')  #--device cuda:1
16.     # 解析参数
17.     opt = parser.parse_args()
18.     return opt
20. opt = parse_opt()  # 调用解析函数
21. Dropout_Val = opt.Dropout_Val
22. device = torch.device(opt.device)
24. image_path = "D:\\Pycharm\\Pytorch_test\\数据集\\练手数据集\\1.jpg"
25. image = Image.open(image_path)   #注意格式为RGBA
26. print(image)
28. image = image.convert("RGB")     #将格式变成RGB
29. print(image)
31. #确保你的图像预处理步骤（如归一化）与模型训练时使用的步骤相匹配。通常，VGG16 需要将图像归一化到 [0, 1] 范围内，
32. # 并可能需要减去均值和除以标准差
33. transform = torchvision.transforms.Compose([
34.     torchvision.transforms.Resize((224, 224)),
35.     torchvision.transforms.ToTensor(),
36.     torchvision.transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
37. ])
39. image = transform(image)
40. print(image.shape)
42. # 类别标签
43. class_names = ['ant', 'bee', 'dog']  # 根据实际情况填写

复制代码

2.搭建VGG16网络结构

1. class VGG16(nn.Module):
2.     def __init__(self):
3.         super(VGG16, self).__init__()
4.         self.model = nn.Sequential(  # 构建子类，可以减少foward代码撰写
5.             nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3, stride=1, padding=1),
6.             nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, stride=1, padding=1),
7.             nn.MaxPool2d(kernel_size=2, stride=2), #最大池化将224变成112
8.             nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, stride=1, padding=1),
9.             nn.Conv2d(in_channels=128, out_channels=128, kernel_size=3, stride=1, padding=1),
10.             nn.MaxPool2d(kernel_size=2, stride=2), # 56x56
11.             nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, stride=1, padding=1),
12.             nn.Conv2d(in_channels=256, out_channels=256, kernel_size=3, stride=1, padding=1),
13.             nn.Conv2d(in_channels=256, out_channels=256, kernel_size=3, stride=1, padding=1),
14.             nn.MaxPool2d(kernel_size=2, stride=2),  # 28x28
15.             nn.Conv2d(in_channels=256, out_channels=512, kernel_size=3, stride=1, padding=1),
16.             nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=1, padding=1),
17.             nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=1, padding=1),
18.             nn.MaxPool2d(kernel_size=2, stride=2), # 14x14
19.             nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=1, padding=1),
20.             nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=1, padding=1),
21.             nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=1, padding=1),
22.             nn.MaxPool2d(kernel_size=2, stride=2),  # 7x7
23.         )
24.         # 使用AdaptiveAvgPool2d来确保输出为固定大小
25.         self.avgpool = nn.AdaptiveAvgPool2d((7, 7))
27.         # 全连接层
28.         self.fc1 = nn.Linear(in_features=512 * 7 * 7, out_features=4096)
29.         self.fc2 = nn.Linear(in_features=4096, out_features=4096)
30.         self.fc3 = nn.Linear(in_features=4096, out_features=3)
32.         self.relu = nn.ReLU()
33.         self.dropout = nn.Dropout(Dropout_Val)
35.     def forward(self, x):
36.         x = self.model(x)
37.         x = self.avgpool(x)  # 使用自适应平均池化
38.         x = x.view(x.size(0), -1)  # 拉平操作
39.         x = self.relu(self.fc1(x))
40.         x = self.dropout(x)
41.         x = self.relu(self.fc2(x))
42.         x = self.dropout(x)
43.         x = self.fc3(x)
44.         return x

复制代码

3.输出测试效果
输出测试效果需要将图片送入VGG16网络进行盘算，带入训练好的权值vgg16_1.pth，得出预测效果，将预测的效果输出成概率从而盘算是什么品种。

1. model = VGG16()
2. model = torch.load("vgg16_1.pth")
3. #模型的权重在GPU上，而输入张量在CPU上。要解决这个问题，你可以将输入张量移动到GPU
4. device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
5. model.to(device)
6. image = image.to(device)
7. #模型的权重在CPU上，而输入张量在GPU上。要解决这个问题，你可以将输入张量移动到CPU
8. #model = torch.load("tudui_0.pth",map_location=torch.device('cpu'))
9. image = torch.reshape(image,(1,3,224,224))
10. model.eval()
11. with torch.no_grad():
12.     output = model(image)
13. predicted_index = output.argmax(1).item()  # 获取预测的索引
14. print(output.argmax(1))
15. print(output)   #输出结果预测的是第六个类别
16. print("Predicted index:", predicted_index)
17. # 输出对应的类别名称
18. print("Predicted class:", class_names[predicted_index])

复制代码

测试输出效果

着实多训练频频预测效果还是可以的。
测试整体代码

1. # vgg16网络测试文件,第一代测试代码，主要功能如下# 恣意输入一张图片，输出判断范例,二代与一代相比就是多了参数标准化
2. import torch
3. import torchvision
4. from PIL import Image
5. from torch import nn
6. from torch.nn import MaxPool2d
7. import argparse
8. from pathlib import Path
10. #--------------------------1.参数数据初始化-----------------------------------
11. def parse_opt():
12.     parser = argparse.ArgumentParser()  # 创建 ArgumentParser 对象
13.     parser.add_argument('--Dropout_Val', type=int, default=0.4, help='Dropout_Val number')  # 添加参数
14.     #--device "cuda:0,cuda:1" 启用多个设备
15.     parser.add_argument('--device', default='cuda:0', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')  #--device cuda:1
16.     # 解析参数
17.     opt = parser.parse_args()
18.     return opt
20. opt = parse_opt()  # 调用解析函数
21. Dropout_Val = opt.Dropout_Val
22. device = torch.device(opt.device)
24. image_path = "D:\\Pycharm\\Pytorch_test\\数据集\\练手数据集\\1.jpg"
25. image = Image.open(image_path)   #注意格式为RGBA
26. print(image)
28. image = image.convert("RGB")     #将格式变成RGB
29. print(image)
31. #确保你的图像预处理步骤（如归一化）与模型训练时使用的步骤相匹配。通常，VGG16 需要将图像归一化到 [0, 1] 范围内，
32. # 并可能需要减去均值和除以标准差
33. transform = torchvision.transforms.Compose([
34.     torchvision.transforms.Resize((224, 224)),
35.     torchvision.transforms.ToTensor(),
36.     torchvision.transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
37. ])
39. image = transform(image)
40. print(image.shape)
42. # 类别标签
43. class_names = ['ant', 'bee', 'dog']  # 根据实际情况填写
44. #-------------------------------------2.搭建VGG16网络结构---------------------------------------------class VGG16(nn.Module):
45.     def __init__(self):
46.         super(VGG16, self).__init__()
47.         self.model = nn.Sequential(  # 构建子类，可以减少foward代码撰写
48.             nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3, stride=1, padding=1),
49.             nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, stride=1, padding=1),
50.             nn.MaxPool2d(kernel_size=2, stride=2), #最大池化将224变成112
51.             nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, stride=1, padding=1),
52.             nn.Conv2d(in_channels=128, out_channels=128, kernel_size=3, stride=1, padding=1),
53.             nn.MaxPool2d(kernel_size=2, stride=2), # 56x56
54.             nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, stride=1, padding=1),
55.             nn.Conv2d(in_channels=256, out_channels=256, kernel_size=3, stride=1, padding=1),
56.             nn.Conv2d(in_channels=256, out_channels=256, kernel_size=3, stride=1, padding=1),
57.             nn.MaxPool2d(kernel_size=2, stride=2),  # 28x28
58.             nn.Conv2d(in_channels=256, out_channels=512, kernel_size=3, stride=1, padding=1),
59.             nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=1, padding=1),
60.             nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=1, padding=1),
61.             nn.MaxPool2d(kernel_size=2, stride=2), # 14x14
62.             nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=1, padding=1),
63.             nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=1, padding=1),
64.             nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=1, padding=1),
65.             nn.MaxPool2d(kernel_size=2, stride=2),  # 7x7
66.         )
67.         # 使用AdaptiveAvgPool2d来确保输出为固定大小
68.         self.avgpool = nn.AdaptiveAvgPool2d((7, 7))
70.         # 全连接层
71.         self.fc1 = nn.Linear(in_features=512 * 7 * 7, out_features=4096)
72.         self.fc2 = nn.Linear(in_features=4096, out_features=4096)
73.         self.fc3 = nn.Linear(in_features=4096, out_features=3)
75.         self.relu = nn.ReLU()
76.         self.dropout = nn.Dropout(Dropout_Val)
78.     def forward(self, x):
79.         x = self.model(x)
80.         x = self.avgpool(x)  # 使用自适应平均池化
81.         x = x.view(x.size(0), -1)  # 拉平操作
82.         x = self.relu(self.fc1(x))
83.         x = self.dropout(x)
84.         x = self.relu(self.fc2(x))
85.         x = self.dropout(x)
86.         x = self.fc3(x)
87.         return x
88. #---------------------------3.输出测试效果-----------------------------model = VGG16()
89. model = torch.load("vgg16_1.pth")
90. #模型的权重在GPU上，而输入张量在CPU上。要解决这个问题，你可以将输入张量移动到GPU
91. device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
92. model.to(device)
93. image = image.to(device)
94. #模型的权重在CPU上，而输入张量在GPU上。要解决这个问题，你可以将输入张量移动到CPU
95. #model = torch.load("tudui_0.pth",map_location=torch.device('cpu'))
96. image = torch.reshape(image,(1,3,224,224))
97. model.eval()
98. with torch.no_grad():
99.     output = model(image)
100. predicted_index = output.argmax(1).item()  # 获取预测的索引
101. print(output.argmax(1))
102. print(output)   #输出结果预测的是第六个类别
103. print("Predicted index:", predicted_index)
104. # 输出对应的类别名称
105. print("Predicted class:", class_names[predicted_index])

复制代码

最开始训练的次数有点少，导致预测效果不理想，厥后去用饭前设置训练epochs = 500次，返来发现效果变好了一点。提高正确率的方式很多，还可以丰富训练集。留意我的权值文件权值vgg16_1.pth，大概使用的是权值vgg16_2.pth，代码我就不改了。主要是要明白以上代码。
以上就是本人的心得与总结，如有不足之处请多多包涵。
百度网盘链接代码权值及训练图片： https://pan.baidu.com/s/14xixodOGVEMK-KpE5rZTtw
提取码: dwrg