pytorch官方代码demo（Lenet）解析笔记【B站UP主“霹雳吧啦Wz”视频观看】

小橙子爱蜜蜂

已于 2022-11-12 21:41:50 修改

阅读量608

点赞数

分类专栏：深度学习代码解析文章标签： pytorch 深度学习

于 2022-11-12 20:56:12 首次发布

本文链接：https://blog.csdn.net/weixin_45069367/article/details/127824222

版权

深度学习代码解析专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一、Lenet5网络结构

二、model.py

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


# 定义类（类名LeNet）,nn.Moudle是父类
class LeNet(nn.Module):
    # 初始化函数【实现在搭建网络中所需要的一些网络层结构】
    def __init__(self):
        super(LeNet, self).__init__()  # 【Super继承父类的构造函数】Super函数解决在多层继承中，调用父类方法可能会出现的问题（涉及到多继承都会使用Super）
        self.conv1 = nn.Conv2d(3, 16, 5) #卷积：(输入特征的深度【输入是RGB彩色图片】，输出特征的深度，即卷积核的个数【16个卷积核（使用几个卷积核就会生成多少维的特征矩阵）】，卷积核尺寸【5*5】)
        self.pool1 = nn.MaxPool2d(2, 2) #下采样：Maxpool2d方法
        self.conv2 = nn.Conv2d(16, 32, 5)
        self.pool2 = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(32 * 5 * 5, 120) #全连接层的输入是一维向量，需要将得到的特征矩阵展平为一维向量。（120是LeNet的结点个数）
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    # forward函数定义正向传播的过程
    def forward(self, x): #x是输入数据（待处理的数据，没处理前是图片）
        #经过卷积层1得到的输出经过relu激活函数
        x = F.relu(self.conv1(x))  # input(3, 32, 32) output(16, 28, 28)
        x = self.pool1(x)  # output(16, 14, 14)
        x = F.relu(self.conv2(x))  # output(32, 10, 10)
        x = self.pool2(x)  # output(32, 5, 5)
        #view函数将特征矩阵展出一维向量（这里的-1，表示不确定展开几行）
        x = x.view(-1, 32 * 5 * 5)  # output(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

（1）Conv2d方法的官方说明文档链接：

https://pytorch.org/docs/stable/generated/torch.nn.Conv2d.html?highlight=conv2d#torch.nn.Conv2d

$N= \left ( W-F+2P \right )/S + 1$

其中【输入图片大小为W*W】，【Filter大小F*F】，【步长S】，【padding的像素数为P】。

（根据上述公式，Lenet网络conv1层的输入：input（3，32，32），则一层卷积后的尺寸大小为：（32-5+2*0）/1 +1）=28，output（16，28，28））

（3）Pytorch Tensor的通道排序：[batch，channel，height，width]

（4）下采样层Pool池化层，MaxPool2d方法：

池化层只改变特征矩阵的高与宽，不会影响矩阵的深度。

（根据（2）中公式，pool1下采样层输入：input（16，28，28），则池化后的尺寸大小为：（28-2+2*0）/2 +1）=14，output（16，14，14））

（5）View（）函数：

view中一个参数定为-1，代表动态调整这个维度上的元素个数，以保证元素的总数不变。

（6）调试，查看终端网络的结构:

# 测试
import torch

intput1 = torch.rand([32, 3, 32, 32])  # batch数量:32,channel深度：3，heigh高：32，width宽：32
model = LeNet()  # 实例化模型
print(model)
output = model(intput1)

三、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


def main():
    # Compose将所使用的预处理的方法打包成一个整体
    transform = transforms.Compose(
        [transforms.ToTensor(),
         transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

    # 50000张训练图片
    # 第一次使用时要将download设置为True才会自动去下载数据集
    # transform是对图像进行预处理的函数
    train_set = torchvision.datasets.CIFAR10(root='./data', train=True,
                                             download=False, transform=transform)
    # 将训练集导入进来，分成批次
    # 【batch_size】：每次随机拿出36张图片进行训练
    # 【shuffle】：数据集是否打乱，True为打乱
    # 【num_workers】：载入数据的线程数
    train_loader = torch.utils.data.DataLoader(train_set, batch_size=36,
                                               shuffle=True, num_workers=0)

    # 10000张验证图片
    # 第一次使用时要将download设置为True才会自动去下载数据集
    val_set = torchvision.datasets.CIFAR10(root='./data', train=False,
                                           download=False, transform=transform)
    val_loader = torch.utils.data.DataLoader(val_set, batch_size=5000,
                                             shuffle=False, num_workers=0)
    val_data_iter = iter(val_loader)
    val_image, val_label = val_data_iter.next()

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

    net = LeNet()
    loss_function = nn.CrossEntropyLoss()
    optimizer = optim.Adam(net.parameters(), lr=0.001)

    for epoch in range(5):  # loop over the dataset multiple times

        running_loss = 0.0
        for step, data in enumerate(train_loader, start=0):
            # get the inputs; data is a list of [inputs, labels]
            inputs, labels = data

            # zero the parameter gradients
            optimizer.zero_grad()
            # forward + backward + optimize
            outputs = net(inputs)
            loss = loss_function(outputs, labels)
            loss.backward()
            optimizer.step()

            # print statistics
            running_loss += loss.item()
            if step % 500 == 499:    # print every 500 mini-batches
                with torch.no_grad():
                    outputs = net(val_image)  # [batch, 10]
                    predict_y = torch.max(outputs, dim=1)[1]
                    accuracy = torch.eq(predict_y, val_label).sum().item() / val_label.size(0)

                    print('[%d, %5d] train_loss: %.3f  test_accuracy: %.3f' %
                          (epoch + 1, step + 1, running_loss / 500, accuracy))
                    running_loss = 0.0

    print('Finished Training')

    save_path = './Lenet.pth'
    torch.save(net.state_dict(), save_path)


if __name__ == '__main__':
    main()

（1）transforms.ToTensor：