0
0

pytorch——VGG网络搭建

🚗VGG介绍

VGG 在2014年由牛津大学著名研究组 VGG（Visual Geometry Group）提出，

（论文地址：https://arxiv.org/abs/1409.1556）

获得该年 ImageNet 竞赛中 Localization Task（定位任务）第一名和Classification Task（分类任务）第二名。（可以说是非常的厉害）

🚓那VGG它到底厉害在哪里呢？

通过堆叠多个小卷积核来替代大尺度卷积核，可以减少训练参数，同时能保证相同的感受野

🚓那什么是感受野呢？

决定某一层输出结果中一个元素所对应的输入层的区域大小，被称作感受野（receptive field）

（简单来说就是输出feature map上的一个单元 对应 输入层（上层）上的区域大小）

🚗例如上图：maxpool1 感受野为2 （意思是上一层1格 对应 下一层2格）

  1.                conv1 感受野为5

🚓计算公式

我们的感受野的计算公式为：

F ( i + 1) 为第 i +1 层感受野
Stride 为第 i 层的步距
Ksize 为 卷积核 或 池化核 尺寸

🚓问题一：

堆叠两个3×3的卷积核替代5x5的卷积核，堆叠三个3×3的卷积核替代7x7的卷积核。

(VGG网络中卷积的Stride默认为1)

替代前后感受野是否相同呢？

根据公式

（第一层）Feature map: F(1) = 1

（第二层）Conv3x3(3)：F(2)=(F(1)-1) * 1 + 3= (1-1) * 1 + 3 =3

（第三层）Conv3x3(2): F(3)=(F(2)-1)*1 + 3 = (3-1)*1+3=5

（5×5卷积核感受野）

（第四层）Conv3x3(1): F(4)=(F(3)-1)*1+3=(5-1)*1+3=7

（7×7卷积核感受野）

2个3×3的卷积核和一个5x5的卷积核感受野相同

证明可以通过**堆叠两个3×3的卷积核替代5x5的卷积核，堆叠三个3×3的卷积核替代7x7的卷积核 **

🚓问题二：

堆叠3×3卷积核后训练参数是否真的减少了？

注：CNN参数个数 = 卷积核尺寸×卷积核深度 × 卷积核组数 = 卷积核尺寸 × 输入特征矩阵深度 × 输出特征矩阵深度
现假设 输入特征矩阵深度 = 输出特征矩阵深度 = C

使用7×7卷积核所需参数个数：

堆叠三个3×3的卷积核所需参数个数：

**很明显27小于49 **

🚓网络图

VGG网络有多个版本，

我们一般采用VGG16 （16的意思是16层=12层卷积层+4层全连接层）

其网络结构如下如所示：

看图和计算我们可以知道，经3×3卷积的特征矩阵的尺寸是不改变的：

out =(in −F+2P)/S+1=(in ​−3+2)/1+1= in

out = in 大小一样

🚗pytorch搭建VGG网络

VGG网络分为 卷积层提取特征 和 全连接层进行分类 这两个模块

🚓1. model.py

  1. import torch.nn as nn
  2. import torch
  4. class VGG(nn.Module):
  5.     def __init__(self, features, num_classes=1000, init_weights=False):
  6.         super(VGG, self).__init__()
  7.         self.features = features            # 卷积层提取特征
  8.         self.classifier = nn.Sequential(    # 全连接层进行分类
  9.             nn.Dropout(p=0.5),
  10.             nn.Linear(512*7*7, 2048),
  11.             nn.ReLU(True),
  12.             nn.Dropout(p=0.5),
  13.             nn.Linear(2048, 2048),
  14.             nn.ReLU(True),
  15.             nn.Linear(2048, num_classes)
  16.         )
  17.         if init_weights:
  18.             self._initialize_weights()  #初始化权重
  20.     def forward(self, x):
  21.         # N x 3 x 224 x 224
  22.         x = self.features(x)
  23.         # N x 512 x 7 x 7
  24.         x = torch.flatten(x, start_dim=1)
  25.         # N x 512*7*7
  26.         x = self.classifier(x)
  27.         return x
  29.     def _initialize_weights(self):
  30.         for m in self.modules():
  31.             if isinstance(m, nn.Conv2d):
  32.                 # nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
  33.                 nn.init.xavier_uniform_(m.weight)
  34.                 if m.bias is not None:
  35.                     nn.init.constant_(m.bias, 0)
  36.             elif isinstance(m, nn.Linear):
  37.                 nn.init.xavier_uniform_(m.weight)
  38.                 # nn.init.normal_(m.weight, 0, 0.01)
  39.                 nn.init.constant_(m.bias, 0)

🚕神奇处理之处

  1. # vgg网络模型配置列表，数字表示卷积核个数，'M'表示最大池化层
  2. cfgs = {
  3.     'vgg11': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],                                            # 模型A
  4.     'vgg13': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],                                    # 模型B
  5.     'vgg16': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],                    # 模型D
  6.     'vgg19': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'],     # 模型E
  7. }
  9. # 卷积层提取特征
  10. def make_features(cfg: list): # 传入的是具体某个模型的参数列表
  11.     layers = []
  12.     in_channels = 3        # 输入的原始图像(rgb三通道)
  13.     for v in cfg:
  14.         # 如果是最大池化层，就进行池化
  15.         if v == "M":
  16.             layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
  17.         # 不然就是卷积层
  18.         else:
  19.             conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
  20.             layers += [conv2d, nn.ReLU(True)]
  21.             in_channels = v
  22.     return nn.Sequential(*layers)  # 单星号(*)将参数以元组(tuple)的形式导入
  24. def vgg(model_name="vgg16", **kwargs):  # 双星号(**)将参数以字典的形式导入
  25.     try:
  26.         cfg = cfgs[model_name]
  27.     except:
  28.         print("Warning: model number {} not in cfgs dict!".format(model_name))
  29.         exit(-1)
  30.     model = VGG(make_features(cfg), **kwargs) #**kwargs是你传入的字典数据
  31.     return model

🚓2. train.py

和pytorch——AlexNet——训练花分类数据集_heart_6662的博客-CSDN博客的一样（数据还是花的数据）

  1. import os
  2. import json
  4. import torch
  5. import torch.nn as nn
  6. from torchvision import transforms, datasets
  7. import torch.optim as optim
  8. from tqdm import tqdm
  10. from model import vgg
  12. def main():
  13.     device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
  14.     print("using {} device.".format(device))
  16.     data_transform = {
  17.         "train": transforms.Compose([transforms.RandomResizedCrop(224),
  18.                                      transforms.RandomHorizontalFlip(),
  19.                                      transforms.ToTensor(),
  20.                                      transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]),
  21.         "val": transforms.Compose([transforms.Resize((224, 224)),
  22.                                    transforms.ToTensor(),
  23.                                    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])}
  25.     data_root = os.path.abspath(os.path.join(os.getcwd(), "../.."))  # get data root path
  26.     image_path = os.path.join(data_root, "data_set", "flower_data")  # flower data set path
  27.     assert os.path.exists(image_path), "{} path does not exist.".format(image_path)
  28.     train_dataset = datasets.ImageFolder(root=os.path.join(image_path, "train"),
  29.                                          transform=data_transform["train"])
  30.     train_num = len(train_dataset)
  32.     # {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4}
  33.     flower_list = train_dataset.class_to_idx
  34.     cla_dict = dict((val, key) for key, val in flower_list.items())
  35.     # write dict into json file
  36.     json_str = json.dumps(cla_dict, indent=4)
  37.     with open('class_indices.json', 'w') as json_file:
  38.         json_file.write(json_str)
  40.     batch_size =32
  41.     nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8])  # number of workers
  42.     print('Using {} dataloader workers every process'.format(nw))
  44.     train_loader = torch.utils.data.DataLoader(train_dataset,
  45.                                                batch_size=batch_size, shuffle=True,
  46.                                                num_workers=0)
  48.     validate_dataset = datasets.ImageFolder(root=os.path.join(image_path, "val"),
  49.                                             transform=data_transform["val"])
  50.     val_num = len(validate_dataset)
  51.     validate_loader = torch.utils.data.DataLoader(validate_dataset,
  52.                                                   batch_size=batch_size, shuffle=False,
  53.                                                   num_workers=0)
  54.     print("using {} images for training, {} images for validation.".format(train_num,
  55.                                                                            val_num))
  57.     # test_data_iter = iter(validate_loader)
  58.     # test_image, test_label = test_data_iter.next()
  60.     model_name = "vgg16"
  61.     net = vgg(model_name=model_name, num_classes=5, init_weights=True)
  62.     net.to(device)
  63.     loss_function = nn.CrossEntropyLoss()
  64.     optimizer = optim.Adam(net.parameters(), lr=0.0001)
  66.     epochs = 30
  67.     best_acc = 0.0
  68.     save_path = './{}Net.pth'.format(model_name)
  69.     train_steps = len(train_loader)
  70.     for epoch in range(epochs):
  71.         # train
  72.         net.train()
  73.         running_loss = 0.0
  74.         train_bar = tqdm(train_loader)
  75.         for step, data in enumerate(train_bar):
  76.             images, labels = data
  77.             optimizer.zero_grad()
  78.             outputs = net(images.to(device))
  79.             loss = loss_function(outputs, labels.to(device))
  80.             loss.backward()
  81.             optimizer.step()
  83.             # print statistics
  84.             running_loss += loss.item()
  86.             train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(epoch + 1,
  87.                                                                      epochs,
  88.                                                                      loss)
  90.         # validate
  91.         net.eval()
  92.         acc = 0.0  # accumulate accurate number / epoch
  93.         with torch.no_grad():
  94.             val_bar = tqdm(validate_loader)
  95.             for val_data in val_bar:
  96.                 val_images, val_labels = val_data
  97.                 outputs = net(val_images.to(device))
  98.                 predict_y = torch.max(outputs, dim=1)[1]
  99.                 acc += torch.eq(predict_y, val_labels.to(device)).sum().item()
  101.         val_accurate = acc / val_num
  102.         print('[epoch %d] train_loss: %.3f  val_accuracy: %.3f' %
  103.               (epoch + 1, running_loss / train_steps, val_accurate))
  105.         if val_accurate > best_acc:
  106.             best_acc = val_accurate
  107.             torch.save(net.state_dict(), save_path)
  109.     print('Finished Training')
  111. if __name__ == '__main__':
  112.     main()

3. predict.py

pytorch——AlexNet——训练花分类数据集_heart_6662的博客-CSDN博客与之前一样

  1. import os
  2. import json
  4. import torch
  5. from PIL import Image
  6. from torchvision import transforms
  7. import matplotlib.pyplot as plt
  9. from model import vgg
  11. def main():
  12.     device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
  14.     data_transform = transforms.Compose(
  15.         [transforms.Resize((224, 224)),
  16.          transforms.ToTensor(),
  17.          transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
  19.     # load image
  20.     img_path = "../tulip.jpg"
  21.     assert os.path.exists(img_path), "file: '{}' dose not exist.".format(img_path)
  22.     img = Image.open(img_path)
  23.     plt.imshow(img)
  24.     # [N, C, H, W]
  25.     img = data_transform(img)
  26.     # expand batch dimension
  27.     img = torch.unsqueeze(img, dim=0)
  29.     # read class_indict
  30.     json_path = './class_indices.json'
  31.     assert os.path.exists(json_path), "file: '{}' dose not exist.".format(json_path)
  33.     json_file = open(json_path, "r")
  34.     class_indict = json.load(json_file)
  35.     
  36.     # create model
  37.     model = vgg(model_name="vgg16", num_classes=5).to(device)
  38.     # load model weights
  39.     weights_path = "./vgg16Net.pth"
  40.     assert os.path.exists(weights_path), "file: '{}' dose not exist.".format(weights_path)
  41.     model.load_state_dict(torch.load(weights_path, map_location=device))
  43.     model.eval()
  44.     with torch.no_grad():
  45.         # predict class
  46.         output = torch.squeeze(model(img.to(device))).cpu()
  47.         predict = torch.softmax(output, dim=0)
  48.         predict_cla = torch.argmax(predict).numpy()
  50.     print_res = "class: {}   prob: {:.3}".format(class_indict[str(predict_cla)],
  51.                                                  predict[predict_cla].numpy())
  52.     plt.title(print_res)
  53.     for i in range(len(predict)):
  54.         print("class: {:10}   prob: {:.3}".format(class_indict[str(i)],
  55.                                                   predict[i].numpy()))
  56.     plt.show()
  58. if __name__ == '__main__':
  59.     main()

🚗注意

VGG网络模型深度较深，需要使用算力强大GPU进行训练(而且要内存大一点的GPU，我3050跑不动，pytorch会报错GPU内存不足)

你也可以试试改小batch_size

标签： pytorch 网络 深度学习
本文转载自: https://blog.csdn.net/qq_62932195/article/details/122416591
版权归原作者 heart_6662 所有， 如有侵权，请联系我们删除。
登录后发布评论

“pytorch——VGG网络搭建”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？