基于LeNet-5网络实现手写体分类（入门版，超详细）

基于LeNet-5网络实现手写体分类

ps：作者是很用心写的，如果觉得不错，请给作者一点鼓励噢！（点赞收藏评论噢）
数据集
图像都是28*28大小的灰度图像，每个像素的是一个八位字节（0~255），包含了60000张的训练图像和10000张的测试图像，主要是下面的四个文件

1 引入库

import torch
import torchvision
from torch.utils.data import DataLoader
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim

2 设置参数

后面会用到

#设置参数
batch_size_train = 64#训练集每批次加载64张图片
batch_size_test = 1000#测试集每批次加载1000张图片
learning_rate = 0.01#学习率，默认为0.01
momentum = 0.5#动量参数
log_interval = 10#运行10批次打印一次结果

3 准备数据集

#准备数据集
train_loader = torch.utils.data.DataLoader(
    torchvision.datasets.MNIST('F:\\智能实验\\第五次\\data\\mnist (2)',train=True,download=False,
                               transform=torchvision.transforms.Compose([
                               torchvision.transforms.ToTensor(),
                               torchvision.transforms.Normalize(
                                 (0.1307,), (0.3081,))
                             ])),
  batch_size=batch_size_train, shuffle=True)
#如果没有下载数据集，则路径设置为‘./data',把download处改为Ture，运行上面的程序后，会自动将数据集下载到目录下的data文件夹；
#如果已经下载好了数据集，直接把路径改为mnist的上一级路径，这里要特别注意不然会报错
test_loader = torch.utils.data.DataLoader(
    torchvision.datasets.MNIST('F:\\智能实验\\第五次\\data\\mnist (2)',train=False,download=False,
                               transform=torchvision.transforms.Compose([
                               torchvision.transforms.ToTensor(),
                               torchvision.transforms.Normalize(
                                 (0.1307,), (0.3081,))
                             ])),
  batch_size=batch_size_test, shuffle=True)

解释：

torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=False, sampler=None, batch_sampler=None, num_workers=0, collate_fn=, pin_memory=False, drop_last=False, timeout=0, worker_init_fn=None)
* dataset:加载数据的数据集
* batch_size: 每批加载多少个样本
* shuffle : 设置为“真”时,在每个epoch对数据打乱.（默认：False）

torchvision.datasets.MNIST(root, train=True, transform=None, target_transform=None, download=False)
*root：minist所在文件夹
*train：如果要载入训练集则为True，测试集则为False
*transform：图片变换
*download：是否已经下载好了数据集
torchvision.transforms.Compose (transforms)
#将多个变换方式结合在一起
torchvision.transforms.ToTensor#将读取数据转化为训练时要用的张量
torchvision.transforms.Normalize(mean,std)#用均值和标准差对张量图像进行标准化处理，mnist数据集均值是0.1307，标准差是0.3081，这些系数都是数据集提供方计算好的数据

4 定义网络结构

使用lenet5网络结构
LeNet-5卷积神经网络模型是Yann LeCun在1998年设计的用于手写数字识别的卷积神经网络，当年美国大多数银行就是用它来识别支票上面的手写数字的，它是早期卷积神经网络中最有代表性的实验系统之一。LenNet-5共有7层（不包括输入层），每层都包含不同数量的训练参数，如下图所示：

class LeNet(nn.Module):
    def __init__(self):
        super(LeNet, self).__init__()
        # 1 input image channel, 6 output channels, 5x5 square convolution
        # kernel
        self.conv1 = nn.Conv2d(1, 6, 5, padding=2)#输入图片尺寸为1*28*28，为保证尺寸不变padding=2
        self.conv2 = nn.Conv2d(6, 16, 5)
        # an affine operation: y = Wx + b
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)
        
        
    def forward(self, x):
        x = F.relu(self.conv1(x))#输出尺寸6*28*28
        x = F.max_pool2d(x, 2)#输出尺寸6*14*14
        x = F.relu(self.conv2(x))#输出尺寸16*10*10
        x = F.max_pool2d(x, 2)#输出尺寸16*5*5
        x = x.view(x.size(0), -1)#由于之后要接入全连接层，所以需要把多维度的tensor展平成一维
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

5 初始化网络和优化函数

net = LeNet()
optimizer = optim.SGD(net.parameters(), lr=learning_rate,
                      momentum=momentum)

解释：这里采用SGD随机梯度下降优化器
加入动量参数后权重更新公式变为

velocity = momentum * velocity - learning_rate * dw
                  w = w + velocity

这样
（1）不仅考虑了当前的梯度下降的方向，还综合考虑了上次更新的情况，使得学习器学习过程的幅度和角度不会太尖锐，特别是遇到来回抖动的情况时大有好转。
（2）当遇到局部极小值时，因为设置了惯性，所以可能可以冲出局部最小值，这样就更可能找到一个全局最小值。

6 测试将网络是否可以放在GPU上

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print('Using device:', device)
net.to(device)

7 模型训练和测试

def train(epoch):
    net.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        data=torch.tensor(data).type(torch.FloatTensor)
        target=torch.tensor(target).type(torch.LongTensor)#pytorch中标签一般为long型，不转换可能会报错
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()#梯度清零
        output = net(data)#实际输出
        loss = nn.CrossEntropyLoss()(output,target)#计算损失函数
        loss.backward()#误差反传
        optimizer.step()#优化器优化
        
        # 打印结果，每10个批次打印一次，即640张图片输出一次结果
        
        if batch_idx % log_interval == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(epoch, batch_idx * len(data),len(train_loader.dataset),100. * batch_idx / len(train_loader), loss.item()))
def test():
    net.eval()
    test_loss = 0
    correct = 0
    with torch.no_grad():
        for data, target in test_loader:
            data=torch.tensor(data).type(torch.FloatTensor)
            target=torch.tensor(target).type(torch.LongTensor)
            data,target = data.to(device), target.to(device)
            output = net(data)
            test_loss += nn.CrossEntropyLoss()(output, target).item()
            pred = output.data.max(1, keepdim=True)[1]
            correct += pred.eq(target.data.view_as(pred)).sum()
            test_loss /= len(test_loader.dataset)
    print('\nTest set: Avg. loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(test_loss, correct, len(test_loader.dataset),100. * correct / len(test_loader.dataset)))
for epoch in range(5):
    train(epoch+1)
    test()
print('Finished!')

8 结果