从0开始学pytorch【2】——手写数字集案例

谁践踏了优雅 2023-10-04 23:21 47阅读 0赞

#### 从0开始学pytorch【2】——手写数字集案例 ####

*  故事背景
 *  调库
 *  加载数据
 *  查看数据结构
 *  建立模型
 *  实例化训练
 *  测试

## 故事背景 ##

在学习pytorch之前，本文通过手写数字集简单案例介绍pytorch深度网络基本流程，即先加载数据、建立模型， 然后模型训练和测试。

## 调库 ##

# 调库
    
    import torch
    from torch import nn
    from torch.nn import functional as F
    from torch import optim
    
    import torchvision
    from matplotlib import pyplot as plt
    
    from utils import plot_image, plot_curve, one_hot

其中utils为自定义类，将下面这个代码块保存为`utils.py`即可。

import  torch
    from    matplotlib import pyplot as plt
    
    
    def plot_curve(data):
        fig = plt.figure()
        plt.plot(range(len(data)), data, color='blue')
        plt.legend(['value'], loc='upper right')
        plt.xlabel('step')
        plt.ylabel('value')
        plt.show()
    
    
    
    def plot_image(img, label, name):
    
        fig = plt.figure()
        for i in range(6):
            plt.subplot(2, 3, i + 1)
            plt.tight_layout()
            plt.imshow(img[i][0]*0.3081+0.1307, cmap='gray', interpolation='none')
            plt.title("{}: {}".format(name, label[i].item()))
            plt.xticks([])
            plt.yticks([])
        plt.show()
    
    
    def one_hot(label, depth=10):
        out = torch.zeros(label.size(0), depth)
        idx = torch.LongTensor(label).view(-1, 1)
        out.scatter_(dim=1, index=idx, value=1)
        return out

## 加载数据 ##

数据集在线加载。'mnist\_data’为保存下载数据地址，`train=True, download=True`，是否为训练集，是则为训练集60k数据，否则为测试集10k数据；若本地有该数据，则加载，若无则自动下载。`torchvision.transforms.ToTensor()` 将numpy类型数据转为Tensor类型， `torchvision.transforms.Normalize((0.1307,),(0.3081))`将数据标准化，即样本值减去0.1307的差再除以0.3081。设置`batch_size` ，假设总共数据有100份，且`batch_size=9`，那么一种有12批数据，前11批数据都有batch\_size那么多的样本，最后一批数据只有一个样本，它是样本数据的互斥完备划分。

# 加载数据
    batch_size = 512
    
    train_loader =  torch.utils.data.DataLoader(
        torchvision.datasets.MNIST(
            'mnist_data', train=True, download=True, transform=torchvision.transforms.Compose([torchvision.transforms.ToTensor(), torchvision.transforms.Normalize((0.1307,),(0.3081))])
        ),
        batch_size = batch_size, shuffle=True
    )
    
    
    test_loader =   torch.utils.data.DataLoader(
        torchvision.datasets.MNIST(
            'mnist_data/', train=False, download=True, transform=torchvision.transforms.Compose([torchvision.transforms.ToTensor(), torchvision.transforms.Normalize((0.1307,),(0.3081))])
        ),
        batch_size = batch_size, shuffle=False
    )

## 查看数据结构 ##

每批次样本有512个，1个通道（图片），28\*28个像素。标准化之后，像素值在-0.4242到2.8215区间。

# 查看数据结构
    
    x, y = next(iter(train_loader))
    print(x.shape, y.shape, x.max(), x.min())
    plot_image(x, y, '维度')
    
    '''
    输出：
    torch.Size([512, 1, 28, 28]) torch.Size([512]) tensor(2.8215) tensor(-0.4242)
    '''

## 建立模型 ##

自定义`Net`类，继承`nn.Module`,初始化中，设置了三个全连接层。

前向传播中，3层网络结构为：  
 o u t = w 3 ∗ R e L U ( w 2 ∗ R e L U ( w 1 ∗ x + b 1 ) + b 2 ) + b 3 R e L U = m a x \{ 0 , x \} out = w\_3\*ReLU(w\_2\*ReLU(w\_1\*x+b\_1)+b\_2)+b\_3 \\\\ ReLU=max\\left \\\{ 0, x \\right \\\} out=w3∗ReLU(w2∗ReLU(w1∗x\+b1)\+b2)\+b3ReLU=max\{ 0,x\}

现在的目标就是求解出这6个参数 w 1 , w 2 , w 3 , b 1 , b 2 , b 3 w\_1,w\_2,w\_3, b\_1,b\_2,b\_3 w1,w2,w3,b1,b2,b3，比如 w 1 w\_1 w1是28\*28行，256列的矩阵， b 1 b\_1 b1是一个标量。并且这6个参数是自动随机初始化的，并不需要像[从0开始学pytorch–线性函数的梯度下降][0_pytorch]中一样，手动设置初始化值。

# 建立模型
    
    class Net(nn.Module):
        def __init__(self):
            super (Net, self).__init__()
    
            self.fc1 = nn.Linear(28*28, 256)
            self.fc2 = nn.Linear(256, 64)
            self.fc3 = nn.Linear(64, 10)
        
        def forward(self, x):
            x = F.relu(self.fc1(x))
            x = F.relu(self.fc2(x))
            x = self.fc3(x)
            return x

## 实例化训练 ##

实例化`net = Net()`，设置优化器为`optim.SGD`，对net中的所有参数`net.parameters()`进行梯度更新，学习率为0.01，动量为0.9。在整个数据集上迭代3次，且数据集划分了batch，每用一个batch就更新一次梯度，这就是小批量梯度下降法。每个batch都通过前向传播，计算出拟合结果`out = net(x)`，然后计算损失`loss = F.mse_loss(out, y_onehot)`。有了损失后，先将以前的梯度信息清空`optimizer.zero_grad()`，计算梯度`loss.backward()`，然后梯度更新一次`optimizer.step()`，如此循环迭代直至结束。每次计算出的新的参数，都会替代原先的参数，或者`net`网络的参数会不断的自动更新。

# 实例化训练
    
    net = Net()
    optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9)
    train_loss = []
    
    for epoch in range(3):
        for batch_idx, (x, y) in enumerate(train_loader):
            x = x.view(x.size(0), 28*28)
            out = net(x)
            y_onehot = one_hot(y)
            loss = F.mse_loss(out, y_onehot)
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
    
            train_loss.append(loss.item())
    
            if batch_idx % 10 == 0:
                print(epoch, batch_idx, loss.item())
    '''
    输出：
    0 0 0.11726564168930054
    0 10 0.0962279811501503
    0 20 0.08725663274526596
    0 30 0.0792681947350502
    0 40 0.07547308504581451
    0 50 0.06947207450866699
    0 60 0.06475400924682617
    0 70 0.06229918450117111
    0 80 0.060089994221925735
    0 90 0.05741911008954048
    0 100 0.054541707038879395
    0 110 0.050673432648181915
    1 0 0.05063045769929886
    1 10 0.049355730414390564
    1 20 0.047676168382167816
    1 30 0.04700469970703125
    1 40 0.04374605417251587
    1 50 0.04329095408320427
    1 60 0.043338268995285034
    1 70 0.04323558136820793
    1 80 0.04095456004142761
    1 90 0.043688442558050156
    1 100 0.04124298691749573
    1 110 0.03916223719716072
    2 0 0.03976568952202797
    ...
    2 80 0.033948544412851334
    2 90 0.03404472768306732
    2 100 0.03158936649560928
    2 110 0.034783411771059036
    '''

## 测试 ##

训练结束后，`net`网络中已经自动更新为最后的参数，我们直接调用`net`，输入样本，就可以得到预测结果。单个的预测或者测试并没有意义，本文感兴趣的是`net`在整个测试集上的综合表现，于是用准确率来刻画，最后得到准确率为88.12%

# 测试
    
    total_correct = 0
    for x, y in test_loader:
        x = x.view(x.size(0), 28*28)
        out = net(x)
        pred = out.argmax(dim=1)
        currect = pred.eq(y).sum().float().item()
        total_correct += currect
    total_num = len(test_loader.dataset)
    acc = total_correct / total_num
    print(acc)
    
    '''
    输出：
    0.8812
    '''

总之，主要步骤分为加载数据、建立模型、模型训练、模型测试这4个阶段。完整项目见[GitHub-pytorch\_2][GitHub-pytorch_2]。

[0_pytorch]: https://blog.csdn.net/AdamCY888/article/details/129466396
[GitHub-pytorch_2]: https://github.com/chenyiadam/pytorch_2.git