一位深度学习小萌新的学渣笔记(二）LeNet+AlexNet网络介绍及代码详解_lenetweight dimension

前言

继续学习霹雳大神的神经网络讲解视频

更新不易，希望大家可以去看原视频支持up主霹雳吧啦Wz

本博文记载的是基于Pytorch框架的LeNet+AlexNet网络

pytorch官方demo(Lenet)
AlexNet网络结构详解与花分类数据集下载
使用pytorch搭建AlexNet并训练花分类数据集

LeNet网络结构详解与模型的搭建

简单介绍LeNet

• LeNet分为卷积层块和全连接层块两个部分。
• 卷积层块⾥的基本单位是卷积层后接最⼤池化层
• 卷积层⽤来识别图像⾥的空间模式，如线条和物体局部，
• 最⼤池化层则⽤来降低卷积层对位置的敏感性。
• LeNet组成 卷积层、 下采样层、 卷积层、 下采样层、 三个全连接层
  

model.py中代码解读

import torch.nn as nn
import torch.nn.functional as F

class LeNet(nn.Module):
    def __init__(self):
        super(LeNet, self).__init__() 
        #super函数解决在多种继承中更好的调用父类super在多继承中经常使用 
        self.conv1 = nn.Conv2d(3, 16, 5)#可以在pytorch官网Docs中查找Conv2d可以找到函数详细的定义#
        #可以显示计算公式 3代表输入特征层的深度，用了16个卷积核、卷积核大小是5*5 
        self.pool1 = nn.MaxPool2d(2, 2)#点击查看MaxPool2d的函数定义，发现没有初始化函数、
        #跳转看其父类MaxPoolNd才能看到初始化参数 （self,kernel_size,，stride=None，padding=0，dilation=1,return_indices=False,ceil_mode=False)
        #如果没有传入stride参数、那stride=kernal_size卷积核大小   
        #这里的2代表卷积核大小，2代表步长 
        self.conv2 = nn.Conv2d(16, 32, 5)#16深度 32卷积核个数 5*%卷积核大小
        self.pool2 = nn.MaxPool2d(2, 2) #这里的2代表卷积核大小，2代表步长 
        self.fc1 = nn.Linear(32*5*5, 120) #全连接层的输入是一个一维的向量，这里需要展平所以是32*5*5 深度*高度*宽度 节点个数为120
        self.fc2 = nn.Linear(120, 84) #上一层的输出120 第二层设计输出84
        self.fc3 = nn.Linear(84, 10)  #上一层的输出84 第二层设计输出需要根据我们的训练集合进行修改，用来实验的具有10个分类任务，所以设为10
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

 def forward(self, x):
        x = F.relu(self.conv1(x))    # input(3, 32, 32) output(16, 28, 28)
        # （深度，高度、宽度） N = 28 = （ 32 - 5 + 0 ）/1 + 1     16 = 卷积核的个数 
        x = self.pool1(x)            # output(16, 14, 14) 池化层只会影响特征矩阵的高和宽不会影响深度，高度和宽度缩小为原来的一半
        x = F.relu(self.conv2(x))    # output(32, 10, 10)  
        # N = 10 = （ 14 - 5 + 0 ）/1 + 1 32卷积核个数
        x = self.pool2(x)            # output(32, 5, 5) #高度和宽度缩小为原来的一半
        x = x.view(-1, 32*5*5)       # output(32*5*5) #view函数可以用于自动展平数据 -1代表第一个维度batch 32*5*5是展平后的数据个数
        x = F.relu(self.fc1(x))      # output(120)
        x = F.relu(self.fc2(x))      # output(84)
        x = self.fc3(x)              # output(10)
        return x #为什么这个分类问题没有使用softmax函数，但是在训练网络过程中计算卷积交叉熵时已经内部实现了一个搞笑的softmax方法
1
2
3
4
5
6
7
8
9
10
11
12

调试信息
import torch
input1 = torch.rand([32, 3, 32, 32])
model = LeNet()
print(model)
output = model(input1)
# 可以  x = F.relu(self.conv1(x)) 设置断点进行调试
1
2
3
4
5
6
7

train.py代码解读

使用到的数据集

先导入所需要的包

import torch
import torchvision
import torch.nn as nn
from model import LeNet
import torch.optim as optim
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np
1
2
3
4
5
6
7
8

下载训练集and初始化

# 50000张训练图片
#用来下载训练集的函数
transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
#用到两个函数对图片进行预处理
#ToTensor是将PIL Image 或者是numpy.ndarra （H x W x C（深度）) 每一维度的像素值都是0-255  转化成tensor （C x H x W)每 一维度的像素值都是改成0.0-1.0 
#Normalize 标准化的一个过程 使用均值(mean)和标准差(std) 来标准化我们的tensor
#标准化过程output[channel]=(input[channel]-mean[channel])/std[channel]  


#下载我们的训练集
# 50000张训练图片
train_set = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=transform)
#参数解析：   
#root参数是代表下载到何处，这里./data不行的话可以用data，train参数如果为true会导入CIFAR10的训练集的样本，download为true就开始自动下载，transform是对图片进行预处理 把download的参数False改成True开始下载
#torchvision.datasets.参看pytorch官方提供的数据集
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

训练集导入

train_loader = torch.utils.data.DataLoader(train_set, batch_size=36,
                                          shuffle=True, num_workers=0)
#这个函数将训练集导入，然后随机分成一个批次36张，将shuffle的参数由False改成True，表示随机batch    #num_worker在window下设置为0
1
2
3

测试集下载and导入 与训练集类似的的方法

# 10000张验证图片
val_set = torchvision.datasets.CIFAR10(root='./data', train=False,
                                       download=False, transform=transform)
                                       #注意这时的train参数是False
val_loader = torch.utils.data.DataLoader(val_set, batch_size=5000,
                                         shuffle=False, num_workers=0)
                                         #注意这里的batch_size直接设为了5000，很大，不像前面的36
1
2
3
4
5
6
7

val_data_iter = iter(val_loader) #将val_loader转化为一个可迭代的迭代器
val_image, val_label = val_data_iter.next() #用next获得一批数据 数据中包含了图像以及图像对应的标签值
1
2

classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

1
2
3