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

【知识点】Cifar10-----VGG/Resnet/mobileNet/inceptionNet 测试_mobilenet cifar10

作者：小舞很执着 | 2024-08-10 07:55:33

赞

踩

mobilenet cifar10

为了熟悉神经网络，搭建建议结构，简化大型网络。

1. Train.py

注：只要更改输入网络名称即可

2. 使用cifar10数据集

首先要完成数据集得解压

  1.  
  2. #把官网下载的cifar-10文件转化为图片保存在新建文件夹Train和Test中
  3.  
  4. import pickle
  5. import glob
  6. import os
  7. import cv2
  8. import numpy as np
  9.  
  10. #通过该函数可以拿到字典类型的数据，包含原始图片数据和label
  11. def unpickle(file):
  12.     with open(file, 'rb') as fo:
  13.         dict = pickle.load(fo, encoding='bytes')
  14.     return dict
  15.  
  16. label_name= ["airplane",
  17.              "automobile",
  18.              "bird",
  19.              "cat",
  20.              "deer",
  21.              "dog",
  22.              "frog",
  23.              "horse",
  24.              "ship",
  25.              "truck"]
  26.  
  27. #通过glob：文件匹配的方式读取当前文件夹下相匹配的文件
  28. train_list = glob.glob("—————————改成自己文件夹名称———————————————\Test_batch*") #data_batch_*-->Test_batch*
  29. print(train_list)
  30. save_path = "—————————改成自己文件夹名称———————————————\Test"  #Train-->Test
  31.  
  32. for l in train_list:
  33.     print(l)
  34.     l_dict = unpickle(l)
  35.     #print(l_dict) #print all
  36.     print(l_dict.keys()) #dict_keys([b'batch_label', b'labels', b'data', b'filenames'])
  37.  
  38.     for im_idx, im_data in enumerate(l_dict[b'data']):  #enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中
  39.         #print(im_idx)
  40.         #print(im_data)  #图片以向量的形式存在
  41.         #打印出索引值和图片，但是图片以向量形式表示，要reshape成为3X32X32，再对3这个维度进行交换，变为32X32X3
  42.  
  43.  
  44.         #利用索引值拿到label,name
  45.         im_label = l_dict[b'labels'][im_idx]
  46.         im_name = l_dict[b'filenames'][im_idx]
  47.        # print(im_label, im_name, im_data)
  48.  
  49.         #将数据存放到新建的训练集文件夹下
  50.         im_label_name = label_name[im_label]
  51.         im_data = np.reshape(im_data, [3, 32, 32])
  52.         im_data = np.transpose(im_data, (1, 2, 0))
  53.  
  54.         #cv2.imshow("im_data", cv2.resize(im_data, (200, 200)))
  55.         #cv2.waitKey(0)
  56.  
  57.         #在Train文件夹下对每一个类创建一个文件夹
  58.         #os作用：如果不存在文件夹，则创建一个新的
  59.         if not os.path.exists("{}/{}".format(save_path,
  60.                                              im_label_name)):
  61.            os.mkdir("{}/{}".format(save_path, im_label_name))
  62.  
  63.         #写入图片
  64.         cv2.imwrite("{}/{}/{}".format(save_path,
  65.                                       im_label_name,
  66.                                       im_name.decode("utf-8")), #此时im_name为byte型，要转化为字符串型，加decode
  67.                                       im_data)

 改文件夹的位置，先写入Train，再写入Test，即运行两次

3. VGG

  1. import torch
  2. import torch.nn as nn
  3. import torch.nn.functional as F
  4.  
  5. class VGGbase(nn.Module):
  6.     def __init__(self):
  7.         super(VGGbase, self).__init__()
  8.  
  9.         # 3 * 28 * 28 (经过crop之后 32 resize到 28)
  10.         self.conv1 = nn.Sequential(   #序列容器，用于搭建神经网络的模块被按照被传入构造器的顺序添加到nn.Sequential()容器中
  11.             nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1), #输入通道为3，输出通道为64
  12.             nn.BatchNorm2d(64), #归一化处理，输出channel数64
  13.             nn.ReLU()
  14.         )
  15.        #卷积不改变图片大小，只改变维度
  16.         # 28 * 28
  17.         self.max_pooling1 = nn.MaxPool2d(kernel_size=2, stride=2)
  18.  
  19.         # 14 * 14
  20.         self.conv2_1 = nn.Sequential(
  21.             nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),
  22.             nn.BatchNorm2d(128),
  23.             nn.ReLU()
  24.         )
  25.  
  26.         self.conv2_2 = nn.Sequential(
  27.             nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1),
  28.             nn.BatchNorm2d(128),
  29.             nn.ReLU()
  30.         )
  31.  
  32.         self.max_pooling2 = nn.MaxPool2d(kernel_size=2, stride=2)
  33.  
  34.         # 7 * 7
  35.         #遇上奇数，设置padding=1
  36.         self.conv3_1 = nn.Sequential(
  37.             nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1),
  38.             nn.BatchNorm2d(256),
  39.             nn.ReLU()
  40.         )
  41.  
  42.         self.conv3_2 = nn.Sequential(
  43.             nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
  44.             nn.BatchNorm2d(256),
  45.             nn.ReLU()
  46.         )
  47.  
  48.         self.max_pooling3 = nn.MaxPool2d(kernel_size=2, stride=2, padding=1)
  49.  
  50.         # 4 * 4
  51.  
  52.         self.conv4_1 = nn.Sequential(
  53.             nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1),
  54.             nn.BatchNorm2d(512),
  55.             nn.ReLU()
  56.         )
  57.  
  58.         self.conv4_2 = nn.Sequential(
  59.             nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
  60.             nn.BatchNorm2d(512),
  61.             nn.ReLU()
  62.         )
  63.  
  64.         self.max_pooling4 = nn.MaxPool2d(kernel_size=2, stride=2)
  65.  
  66.         # 2 * 2
  67.  
  68.         #定义FC层
  69.         # batchsize * 512 * 2 * 2 -->batchsize * (512 * 4)
  70.         self.fc = nn.Linear(512*4, 10)    #nn.Linear(in_features, out_features)
  71.  
  72.     #串联，构造分类网络
  73.     def forward(self, x):
  74.         batchsize = x.size(0)   #第0维度的数据数量
  75.         out = self.conv1(x)
  76.         out = self.max_pooling1(out)
  77.         out = self.conv2_1(out)
  78.         out = self.conv2_2(out)
  79.         out = self.max_pooling2(out)
  80.  
  81.         out = self.conv3_1(out)
  82.         out = self.conv3_2(out)
  83.         out = self.max_pooling3(out)
  84.  
  85.         out = self.conv4_1(out)
  86.         out = self.conv4_2(out)
  87.         out = self.max_pooling4(out)
  88.  
  89.         #展平
  90.         out = out.view(batchsize, -1) #-1：根据具体维度进行计算
  91.  
  92.         #FC层
  93.         # batchsize * c * h * w --> batchsize * n
  94.         out = self.fc(out)
  95.         out = F.log_softmax(out, dim=1)
  96.  
  97.         return out
  98.  
  99. def VGGNet():
  100.  
  101.     return VGGbase()

4. Resnet

  1. """
  2. resnet 跳连结构
  4. """
  5.  
  6.  
  7. import torch
  8. import torch.nn as nn
  9. import torch.nn.functional as F
  10.  
  11. class ResBlock(nn.Module):
  12.     def __init__(self, in_channel, out_channel, stride=1):
  13.         super(ResBlock, self).__init__()
  14.         #定义主干分支
  15.         self.layer = nn.Sequential(
  16.             nn.Conv2d(in_channel, out_channel, kernel_size=3, stride=stride, padding=1),
  17.             nn.BatchNorm2d(out_channel),
  18.             nn.ReLU(),
  19.             nn.Conv2d(out_channel, out_channel, kernel_size=3,stride=1,padding=1),
  20.             nn.BatchNorm2d(out_channel),
  21.         )
  22.  
  23.         #定义跳连分支
  24.         self.shortcut = nn.Sequential()
  25.         if in_channel != out_channel or stride > 1:
  26.             #跳连分支,将输入的结果直连
  27.             self.shortcut=nn.Sequential(
  28.                 nn.Conv2d(in_channel, out_channel, kernel_size=3, stride=stride, padding=1),
  29.                 nn.BatchNorm2d(out_channel),
  30.             )
  31.  
  32.     def forward(self, x):
  33.         out1 = self.layer(x)
  34.         out2 = self.shortcut(x)
  35.         out = out1 + out2
  36.         out = F.relu(out)
  37.         return out
  38.  
  39. class ResNet(nn.Module):
  40.  
  41.     #对多个层的定义
  42.     def make_layer(self, block, out_channel, stride, num_block):  #num_block表示定义多少个卷积层
  43.         layer_list = []  #存放相应的层
  44.         for i in range(num_block):
  45.             if i == 0:
  46.                 in_stride = stride
  47.             else:
  48.                 in_stride = 1
  49.             layer_list.append(block(self.in_channel, out_channel, in_stride))
  50.             self.in_channel = out_channel
  51.  
  52.         return nn.Sequential(*layer_list)
  53.  
  54.     def __init__(self, ResBlock):
  55.  
  56.         super(ResNet, self).__init__()
  57.  
  58.         self.in_channel = 32
  59.  
  60.         self.conv1 = nn.Sequential(
  61.             nn.Conv2d(3, 32, kernel_size=3, stride=1, padding=1),
  62.             nn.BatchNorm2d(32),
  63.             nn.ReLU()
  64.         )
  65.  
  66.         self.layer1 = self.make_layer(ResBlock, 64, 2, 2)
  67.         self.layer2 = self.make_layer(ResBlock, 128, 2, 2)
  68.         self.layer3 = self.make_layer(ResBlock, 256, 2, 2)
  69.         self.layer4 = self.make_layer(ResBlock, 512, 2, 2)
  70.  
  71.         self.fc = nn.Linear(512, 10)  #10个类别
  72.  
  73.     def forward(self, x):
  74.         out = self.conv1(x)
  75.         out = self.layer1(out)
  76.         out = self.layer2(out)
  77.         out = self.layer3(out)
  78.         out = self.layer4(out)
  79.  
  80.         out = F.avg_pool2d(out, 2)  #输出结果转换为1 * 1
  81.         out = out.view(out.size(0), -1)
  82.         out = self.fc(out)
  83.  
  84.         return out
  85.  
  86. def resnet():
  87.     return ResNet(ResBlock)
  88.  
  89.  
  90.

5. mobileNet

  1. import torch
  2. import  torch.nn as nn
  3. import torch.nn.functional as F
  4.  
  5. class mobilenet(nn.Module):
  6.  
  7.     #mobilenet  基本单元
  8.     def conv_dw(self, in_channel, out_channel, stride):
  9.         return nn.Sequential(
  10.             nn.Conv2d(in_channel, in_channel, kernel_size=3, stride=stride, padding=1, groups=in_channel, bias=False),
  11.             nn.BatchNorm2d(in_channel),
  12.             nn.ReLU(),
  13.  
  14.             nn.Conv2d(in_channel, out_channel, kernel_size=1, stride=1, padding=0, bias=False),
  15.             nn.BatchNorm2d(out_channel),
  16.             nn.ReLU(),
  17.         )
  18.  
  19.  
  20.     def __init__(self):
  21.         #核心算子的定义
  22.         super(mobilenet, self).__init__()
  23.  
  24.         self.conv1 = nn.Sequential(  # 序列容器，用于搭建神经网络的模块被按照被传入构造器的顺序添加到nn.Sequential()容器中
  25.             nn.Conv2d(3, 32, kernel_size=3, stride=1, padding=1),  # 输入通道为3，输出通道为64
  26.             nn.BatchNorm2d(32),  # 归一化处理，输出channel数64
  27.             nn.ReLU()
  28.         )
  29.  
  30.         self.conv_dw2 = self.conv_dw(32, 32, 1)
  31.         self.conv_dw3 = self.conv_dw(32, 64, 2)  #进行一次下采样
  32.  
  33.         self.conv_dw4 = self.conv_dw(64, 64, 1)
  34.         self.conv_dw5 = self.conv_dw(64, 128, 2)
  35.  
  36.         self.conv_dw6 = self.conv_dw(128, 128, 1)
  37.         self.conv_dw7 = self.conv_dw(128, 256, 2)
  38.  
  39.         self.conv_dw8 = self.conv_dw(256, 256, 1)
  40.         self.conv_dw9 = self.conv_dw(256, 512, 2)
  41.         #以上conv_dw(*, *, 2) 4个2，即进行2^4=16倍的下采样
  42.  
  43.         self.fc = nn.Linear(512,10)
  44.  
  45.     #对以上算子进行串联，完成前项运算
  46.     def forward(self, x):
  47.  
  48.         out = self.conv1(x)
  49.         out = self.conv_dw2(out)
  50.         out = self.conv_dw3(out)
  51.         out = self.conv_dw4(out)
  52.         out = self.conv_dw5(out)
  53.         out = self.conv_dw6(out)
  54.         out = self.conv_dw7(out)
  55.         out = self.conv_dw8(out)
  56.         out = self.conv_dw9(out)
  57.  
  58.         out = F.avg_pool2d(out, 2)  #上面16倍的下采样，此处采用2 * 2 的＆进行average pooling
  59.         out = out.view(-1, 512)  #转为2维图
  60.         out = self.fc(out)  #对5122维向10维分布转化
  61.  
  62.         return out
  63.  
  64. def mobilenetv1_small():
  65.     return mobilenet()
  66.  
  67.  
  68.

6. inceptionNet

  1. import torch
  2. import torch.nn as nn
  3. import torch.nn.functional as F
  4. """
  5. input: A
  7. 对于resnet
  8. B = A + f(A)  为保证A 和 f(A) 的feature map特征图相同
  9. 所以 
  10. B = g(A) + f(A) 
  11.     g(A): 对A进行判断：如果输入channel和输出channel不相同，或者stride > 2, 对A进行卷积运算，保证和输出的特征图大小一致
  12. ______________________________________________________________________________________________________
  13. 对于inception
  14. 对输入A进行不同的卷积和pooling运算，得到不同的结果后（B1, B2, B3...）进行串联
  15. B1 = f1(A)
  16. B2 = f2(A)
  17. B3 = f3(A)
  18. B4 = f4(A)
  19. concat([B1， B2, B3, B4])
  21. """
  22.  
  23. def ConvBNRelu(in_channel, out_channel, kernel_size):
  24.     return nn.Sequential(
  25.         nn.Conv2d(in_channel, out_channel, kernel_size=kernel_size, stride=1, padding=kernel_size//2),  # //2:整除，得商kernel_size=3, padding=1; kernel_size=5, padding=2; kernel_size=7, padding=3
  26.         nn.BatchNorm2d(out_channel),  # 归一化处理，输出channel数64
  27.         nn.ReLU()
  28.     )
  29.  
  30.  
  31. class BaseInception(nn.Module):
  32.     def __init__(self, in_channel, out_channel_list, reduce_channel_list):
  33.         super(BaseInception, self).__init__()
  34.  
  35.         self.branch1_conv = ConvBNRelu(in_channel, out_channel_list[0], 1)
  36.  
  37.         self.branch2_conv1 = ConvBNRelu(in_channel, reduce_channel_list[0], 1)   #压缩
  38.         self.branch2_conv2 = ConvBNRelu(reduce_channel_list[0], out_channel_list[1], 3)
  39.  
  40.         self.branch3_conv1 = ConvBNRelu(in_channel, reduce_channel_list[1], 1)
  41.         self.branch3_conv2 = ConvBNRelu(reduce_channel_list[1], out_channel_list[2], 5)
  42.  
  43.         self.branch4_pool = nn.MaxPool2d(kernel_size=3, stride=1, padding=1)
  44.         self.branch4_conv = ConvBNRelu(in_channel, out_channel_list[3], 3)
  45.  
  46.     def forward(self, x):
  47.         out1 = self.branch1_conv(x)
  48.  
  49.         out2 = self.branch2_conv1(x)
  50.         out2 = self.branch2_conv2(out2)
  51.  
  52.         out3 = self.branch3_conv1(x)
  53.         out3 = self.branch3_conv2(out3)
  54.  
  55.         out4 = self.branch4_pool(x)
  56.         out4 = self.branch4_conv(out4)
  57.  
  58.         out = torch.cat([out1, out2, out3, out4], dim=1)
  59.  
  60.         return out
  61.  
  62.  
  63. class InceptionNet(nn.Module):
  64.     #初始化
  65.     def __init__(self):
  66.         super(InceptionNet, self).__init__()
  67.  
  68.         self.block1 = nn.Sequential(
  69.             nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=1),
  70.             nn.BatchNorm2d(64),
  71.             nn.ReLU()
  72.         )
  73.  
  74.  
  75.         self.block2 = nn.Sequential(
  76.             nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1),
  77.             nn.BatchNorm2d(128),
  78.             nn.ReLU()
  79.         )
  80.  
  81.         self.block3 = nn.Sequential(
  82.             BaseInception(in_channel=128, out_channel_list=[64, 64, 64, 64], reduce_channel_list=[16, 16]),
  83.             nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
  84.         )
  85.  
  86.         self.block4 = nn.Sequential(
  87.             BaseInception(in_channel=256, out_channel_list=[96, 96, 96, 96], reduce_channel_list=[32, 32]),
  88.             nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
  89.         )
  90.  
  91.         self.fc = nn.Linear(384, 10)  #96 * 4 = 384
  92.  
  93.     #组装算子，完成前向推理
  94.     def forward(self, x):
  95.         out = self.block1(x)
  96.         out = self.block2(out)
  97.         out = self.block3(out)
  98.         out = self.block4(out)
  99.         out = F.avg_pool2d(out, 2)
  100.         out = out.view(out.size(0), -1)
  101.         out = self.fc(out)
  102.  
  103.         return out
  104.  
  105. def InceptionNetSmall():
  106.     return InceptionNet()
  107.

运行结果（Test）
VGG

 

 

 resnet

 

 mobileNet

 

 inceptionNet

 

 

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

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

  

闽ICP备14008679号