lenet pytorch 官方demo学习笔记

教程连接
数据集 cifa10

batch 一批数据集的个数
channel 深度，灰度图为1，rgb为3
height，width 宽高，32

在pytorch官网查文档

model

#///导包时用的是torch
import torch.nn as nn
import torch.nn.functional as F

#///流程：建一个类，这个类要继承nn.Model这个父类，这个类中要实现两个方法，一个是初始化函数（实现在网络中要使用的网络层结构），另一个是forward函数中定义正向传播的过程，当我们实例化这个类之后，将参数传递到这个实例中，就会按照forward的顺序进行正向传播过程
class LeNet(nn.Module):
    def __init__(self)://初始化函数
        super(LeNet, self).__init__()//继承，解决多继承，调用基类的构造函数
        self.conv1 = nn.Conv2d(3, 16, 5)
   #//第一个卷积层（按住alt+鼠标左键查看函数定义：“采用2D卷积对输入进行处理Applies a 2D //convolution over an input signal composed of several input planes.”）
   参数：
    #     self,
    #     in_channels: int,  输入特征矩阵的输入（RGB为3）
    #     out_channels: int,（卷积核的个数=输出为深度维的特征矩阵）
    #     kernel_size: _size_2_t,（卷积核的大小）
    #     stride: _size_2_t = 1,（步距）
    #     padding: _size_2_t = 0,（补齐）
    #     dilation: _size_2_t = 1,（暂时用不到）
    #     groups: int = 1,（暂时用不到）
    #     bias: bool = True,（偏置）
    #     padding_mode: str = 'zeros'  # TODO: refine this type
    # ):
        self.pool1 = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(16, 32, 5)
        self.pool2 = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(32*5*5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)#//10是因为10分类任务，主观修改的

    def forward(self, x):#x代表输入的输入，形式是[batch,channel,height,width]
        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)
        #与全连接层进行拼接，需要展开成为一维向量
        x = x.view(-1, 32*5*5)       # output(32*5*5)#-1代表第一个维度是自动推理的，（batch）
        x = F.relu(self.fc1(x))      # output(120)
        x = F.relu(self.fc2(x))      # output(84)
        x = self.fc3(x)              # output(10)
        return x

#测试
# import torch
#input1=torch.rand([32,3,32,32])
#model=LeNet() #实例化模型
#print（model）
#output=莫得了（input1）   #输入

predict

#调用模型权重进行预测

import torch
import torchvision.transforms as transforms
from PIL import Image
from model import LeNet

transform = transforms.Compose(
    [transforms.Resize((32, 32)),#缩放
     transforms.ToTensor(),#转化成tensor
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])#标准化

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

net = LeNet()
net.load_state_dict(torch.load('Lenet.pth'))#载入权重文件

im = Image.open('1.jpg')#用Image模块载入图像
im = transform(im)  # [C, H, W]#图像的shape一般都是【】，就要转化成pytorch tensor的格式
im = torch.unsqueeze(im, dim=0)  # [N, C, H, W]#最前面增加一个batch的新维度

with torch.no_grad():
    outputs = net(im)
    predict = torch.max(outputs, dim=1)[1].data.numpy()
print(classes[int(predict)])

train

import torch
import torchvision
import torch.nn as nn
from model import LeNet
import torch.optim as optim
import torchvision.transforms as transforms
# 导包

transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])#Compose将一些预处理的方法打包到一起1.toTensor，把PIL或numoy改成tensor2.Normalize是标准化，使用均值与标准差来标准化tensor

# 50000张训练图片
train_set = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=False, transform=transform)#DOWNLOAD改成ture就下载，root表示数据集下载到什么地方，train维ture就会导入训练集的样本，transform就是预处理的函数，在上面
                    
train_loader = torch.utils.data.DataLoader(train_set, batch_size=36,
                                          shuffle=False, num_workers=0)#把数据集导入进来并分成一批一批的，shuffle代表是否随机挑出来，num——workers代表线程数，windows下只能为0

# 10000张验证图片，与上面相同方法
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_loader转化为迭代器，之后通过next的方法就能获取一批数据，就包括测试的图像与图像对应的标签值
val_image, val_label = val_data_iter.next()


# classes = ('plane', 'car', 'bird', 'cat',
#            'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
#将10个标签导入，是元组类型，值不能改index0就对应表签飞机
#用官方的imshow可以看图片（numpy与matplotlib包）29：23
net = LeNet()#实例化模型
loss_function = nn.CrossEntropyLoss()#定义损失函数（有softmax）
optimizer = optim.Adam(net.parameters(), lr=0.001)#优化器用的adam，传入的是要训练的参数，lr是学习率

for epoch in range(5):  # loop over the dataset multiple times
#要将训练集训练多少轮

    running_loss = 0.0#用来累加训练中的损失
    for step, data in enumerate(train_loader, start=0):#遍历训练集样本，enumrate不仅返回每一批的数据data，还返回这一批data对应的步数，start=0从0开始
        # get the inputs; data is a list of [inputs, labels]
        inputs, labels = data#分成图像与标签

        # zero the parameter gradients
        optimizer.zero_grad()#将历史损失梯度清零，不清零可能对计算的历史梯度进行累加（多次进行小batch的训练）
        # forward + backward + optimize
        outputs = net(inputs)#输入网络得到输出
        loss = loss_function(outputs, labels)#根据之前定义的损失函数、输出、真实标签求得损失
        loss.backward()#反向穿播
        optimizer.step()#参数更新

        # print statistics
        running_loss += loss.item()#将loss累加
        if step % 500 == 499:    # print every 500 mini-batches
            with torch.no_grad():#在接下来的计算过程中不要去计算每个节点的误差损失梯度，不用的话，测试过程中也会计算1.会占用更多算力2.占用更多内存资源
                outputs = net(val_image)  # [batch, 10]
                predict_y = torch.max(outputs, dim=1)[1]#寻找输出的最大index在什么位置：网络预测最可能是哪一类，dim是第几个维度，【1】是只需要知道是哪一类就行了
                accuracy = (predict_y == val_label).sum().item() / val_label.size(0)#//与类别进行比较（是个tensor（数值），sum求和是个数值），正确率

                print('[%d, %5d] train_loss: %.3f  test_accuracy: %.3f' %
                      (epoch + 1, step + 1, running_loss / 500, accuracy))#epoch代表迭代到多少轮，step，某一轮到多少步，平均训练误差，准确率
                running_loss = 0.0#清零并进行下一轮

print('Finished Training')

save_path = './Lenet.pth'#模型进行保存
torch.save(net.state_dict(), save_path)#保存的是参数