PyTorch, MNIST

本文目标：理解代码，能够复现
更多细节指路⭐️代码参考原博客写得非常详细🐮

实际上识别手写数字是大二《人工智能》的一个实验，当时用的是TensorFlow

对于这个数据集手动扩展训练数据的话，比如平移、旋转一个角度这样.
Neural Networks and Deep Learning.Michael Nielsen非常通俗易懂，以此为例带人入门神经网络.快看完了，真的对新手友好🐮

Model

# model.py

# 继承于nn.Module这个父类
class MnistNet(nn.Module):
    # 初始化网络结构
    def __init__(self):
        super(MnistNet, self).__init__()
        # 全连接
        self.fc1 = nn.Linear(28 * 28 * 1, 28)
        self.fc2 = nn.Linear(28, 10) # 尺寸，数据集的类别10

    # 正向传播过程
    def forward(self, x):
        # 把三维的张量展平成一维向量
        x = x.view(-1, 28 * 28 * 1)
        x = self.fc1(x)  # [batch_size,28]
        x = F.relu(x)  # [batch_size,28]
        x = self.fc2(x)  # [batch_size,10]
        # return x
        # return F.sigmoid(x)
        return F.log_softmax(x, dim=-1) # 对softmax取对数

Train

import torch
from torch import nn
from torch import optim
import torch.nn.functional as F
import torchvision

# 一般都要分批次进行训练，硬件算力非常有限
train_batch_size = 64
test_batch_size = 1000
# MNIST数据集中图像的尺寸28*28
img_size = 28

def get_dataloader(train=True):
    assert isinstance(train, bool), "train 必须是bool类型"

    # 准备数据集，其中0.1307，0.3081为MNIST数据的均值和标准差，这样操作能够对其进行标准化
    # 因为MNIST只有一个通道（黑白图片）,所以元组中只有一个值
    # 第一次使用要将download设置为True才会自动下载数据集
    # torchvision.datasets在先导入pytorch中的数据集
    dataset = torchvision.datasets.MNIST('/data', train=train, download=False,
                                         transform=torchvision.transforms.Compose([
                                             torchvision.transforms.ToTensor(),
                                             torchvision.transforms.Normalize((0.1307,), (0.3081,)), ]))
    # 准备数据迭代器
    batch_size = train_batch_size if train else test_batch_size
    dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True)
    return dataloader


# model.py
···

# 定义训练的网络模型
mnist_net = MnistNet()
# 优化器adam,学习率设为0.001
optimizer = optim.Adam(mnist_net.parameters(), lr=0.001)
# criterion = nn.NLLLoss()
# criterion = nn.CrossEntropyLoss()
train_loss_list = []
train_count_list = []


def train(epoch):
    mode = True
    mnist_net.train(mode=mode)
    train_dataloader = get_dataloader(train=mode)
    # loss_function = nn.CrossEntropyLoss()
    print(len(train_dataloader.dataset))
    print(len(train_dataloader))
    # 遍历训练集
    for idx, (data, target) in enumerate(train_dataloader):
        # 清除历史梯度
        optimizer.zero_grad()
        # 正向传播
        output = mnist_net(data)
        # 计算损失
        # loss = loss_function(output, target)  #交叉熵损失
        loss = F.nll_loss(output, target) # 对数似然损失
        loss.backward() # 反向传播
        optimizer.step() # 优化器更新参数
        if idx % 10 == 0: # print every 10 mini-batches
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch+1, idx * len(data), len(train_dataloader.dataset),
                       100. * idx / len(train_dataloader), loss.item()))

            train_loss_list.append(loss.item())
            train_count_list.append(idx * train_batch_size + (epoch - 1) * len(train_dataloader))
            # 保存训练得到的参数
            # python中有一种存储方式，可以存储为.pkl文件，可以将python项目过程中用到的一些暂时变量、或者需要提取、暂存的字符串、列表、字典等数据保存起来
            torch.save(mnist_net.state_dict(), "./mnist_net.pkl")
            torch.save(optimizer.state_dict(), './mnist_optimizer.pkl')

# 测试
def test():
    test_loss = 0
    correct = 0
    mnist_net.eval()
    test_dataloader = get_dataloader(train=False)
    with torch.no_grad(): # 冻结参数：
        # 在以下步骤中不用计算每个节点的损失梯度，以防止过度占用内存
        for data, target in test_dataloader:
            output = mnist_net(data)
            test_loss += F.nll_loss(output, target, reduction='sum').item()
            pred = output.data.max(1, keepdim=True)[1]  # 获取最大值的位置,[batch_size,1]
            correct += pred.eq(target.data.view_as(pred)).sum()
    test_loss /= len(test_dataloader.dataset)
    print('\nloss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\n'.format(
        test_loss, correct, len(test_dataloader.dataset),
        100. * correct / len(test_dataloader.dataset)))


if __name__ == '__main__':

    test()
    for i in range(10):  # epoch自己根据需要调轮数
        train(i)
        test()

Result

原代码跑的epoch1的acc=93.26%
其实没训练过的时候，随便也有12%~13%

跑完acc有95.75%

但是《NNDL》上说精度能到99%，所以简单鼓捣一下

1、简单粗暴增加epoch次数
epoch = 10
acc=96.33%

epoch = 30
acc=96.33%

2、损失函数
这里学到的，在pytorch中有两种方式实现交叉熵损失
①loss = nn.CrossEntropyLoss(input,target)

②把softmax概率传入对数似然损失得到的损失函数:

#1. 对输出值计算softmax和取对数
output = F.log_softmax(x,dim=-1)
#2. 使用torch中带权损失
loss = F.nll_loss(output,target)

3、激活函数
把softmax换成sigmoid
不明白

更改超参数得到改进不是很随便的，但是简单任务来看，训练epoch多一点，精度好一点，一般来讲.