基于pytorch的深度学习笔记（一）——进行内置手写数据集的训练和预测

前言

本人在入门深度学习的过程中，遇到了许多问题和坑。鉴于此，将我个人的学习过程和部分经验汇总成为后续的《基于pytorch的深度学习笔记》系列内容，一是整理成为自己的技术学习文档，二是希望能够为后续希望入门机器学习的同僚作为技术参考。本篇仅讨论和记录基于pytorch的深度学习的一些入门案例的代码实现过程。有关算法相关的知识在此部分内容中不进行讨论，如博主有多余精力将开辟新的专栏，对深度学习的相关数学知识和算法知识进行记录。

第一部分 环境的搭建和版本配置

1.1 本次开发环境所依赖环境和显卡驱动版本

本人的计算机搭载了英伟达公司生产的GTX1650显卡，配合CUDA10.1的驱动版本以及pytorch1.8.1进行代码的学习和开发，并将pytorch1.8提前安装在了本地安装好的anaconda3的虚拟环境下（使用的是python3.6）。因为我在前期学习过程中，遇到过很多的网络上的代码没有标注运行环境的版本和依赖库的版本，导致我花费了很多时间调整运行环境和依赖库的版本。故此我将本示例中所须运行环境和依赖包的版本进行详细的标注和说明，尽量为后续的学习者避免上述情况的再次发生。

后续的所有代码都将在此基础上进行编写和运行。若后续笔记内容的以来环境有所变化，我将在文章开始进行标出。

1.2 部分开发环境所依赖的库和版本

albumentations	        0.5.0	
blas	                1.0	
ca-certificates	        2021.4.13	
certifi	                2020.12.5	
chardet	                4.0.0	
cudatoolkit	            10.1.243	
cycler	                0.10.0	
freetype	            2.10.4	
idna	                2.10	
imgaug	                0.4.0	
intel-openmp	        2021.2.0	
jieba	                0.42.1	
jinja2	                3.0.1	
jpeg	                9b	
jsonpath	            0.82	
kiwisolver	            1.3.1	
libpng	                1.6.37	
libtiff	                4.2.0	
libuv	                1.40.0	
lxml	                4.6.3	
lz4-c	                1.9.3	
markupsafe	            2.0.1	
matplotlib	            3.4.2	
mkl	                    2021.2.0	
mkl-service	            2.3.0	
mkl_fft	                1.3.0	
mkl_random	            1.2.1	
ninja	                1.10.2	
numpy	                1.20.2	
numpy-base	            1.20.2	
olefile	                0.46	
opencv-python	        4.5.2.54	
openssl	                1.1.1k	
pandas	                1.2.4	
pillow	                8.2.0	
pip	                    21.1.1	
pygame	                2.0.1	
pyparsing	            2.4.7	
python	                3.7.10	
python-dateutil	        2.8.1	
python_abi	            3.7	
pytorch	                1.8.1	
pytz	                2021.1	
requests	            2.25.1	
scikit-learn	        0.24.2	
scipy	                1.7.0	
selenium	            3.141.0	
setuptools	            49.6.0	
shapely	                1.7.1	
six	                    1.15.0	
sqlite	                3.35.5	
tk	                    8.6.10	
torchvision	            0.9.1	
typing_extensions	    3.7.4.3	
urllib3	                1.26.5	
vc	                    14.2	
vs2015_runtime	        14.28.29325	
vtk	                    9.0.1	
wheel	                0.36.2	
wincertstore	        0.2	
wordcloud	            1.8.1	

上述依赖库并不一定是完全需要安装的，仅列出供参考（示意）

第二部分 代码的编写

2.1 导入所需依赖库

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
#old.utils是我自己在本地old目录下写的一个utils工具类，并非python开源的依赖库
from old.utils import plot_image,plot_curve,one_hot

2.2 编写下载和存储MNIST手写数据集

#提前设置好batch——size
batch_size = 512

# 第一步 加载手写MNIST数据集
#train_loader加载的是训练集的数据
# 即需要设置train=True, 是否需要下载：download=True, 每一个批次的数量：batch_size=batch_size, 是否需要随机打乱：shuffle=True
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加载的是测试集的数据
# 即需要设置train=False, 是否需要下载：download=False（因为之前已经下载好了在本地）
# 每一个批次的数量：batch_size=batch_size, 是否需要随机打乱：shuffle=False
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)
#从训练数据集中取一批数据出来
x, y = next(iter(train_loader))
print(x.shape, y.shape, x.min(), x.max())
plot_image(x, y, 'image sample')

2.3 编写线性网络结构 

#定义一个线性神经网络
class Net(nn.Module):
    #定义网络结构，由3个线形层组成
    def __init__(self):
        super(Net, self).__init__()

        # xw+b
        #fc1为第1层线性层，使用28*28输入，256的输出
        self.fc1 = nn.Linear(28*28, 256)
        # fc2为第2层线性层，使用256输入，64的输出
        self.fc2 = nn.Linear(256, 64)
        # fc3为第3层线性层，使用64输入，10的输出，即回归到0-9十个数字
        self.fc3 = nn.Linear(64, 10)

    #定义前向结构
    def forward(self, x):
        # 输入的x结构: [b, 1, 28, 28]
        # 第一个b：为批次大小。第二个为为通道数，因为MNIST数据为灰度图片，仅有一个通道。第三个和第四个是照片的长宽。
        #第一个激活结构，使用的ReLu
        x = F.relu(self.fc1(x))
        # 第二个激活结构
        x = F.relu(self.fc2(x))
        # 第二个激活结构
        x = self.fc3(x)

        return x

2.4 实例化网络

#实例化网络结构
net = Net()
#设置优化器，此处采用的随机梯度下降SGD，优化的是网络中的参数，学习率设置为lr=0.01， 
optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9)

2.5 编写训练部分

#设定一个训练损失列表用于存储训练
train_loss = []
#编写训练结构，设定训练的轮数epoch为3轮
for epoch in range(3):
    #通过枚举器取位于train_loader的batch
    for batch_idx, (x, y) in enumerate(train_loader):
        # x: [b, 1, 28, 28], y: [512]
        # 将x中的C、H、W拉平为一个维度，即1*28*28，[b, 1, 28, 28] => [b, 784]
        x = x.view(x.size(0), 28*28)
        # => [b, 10]
        out = net(x)
        # [b, 10]
        y_onehot = one_hot(y)
        # loss = mse(out, y_onehot)
        loss = F.mse_loss(out, y_onehot)
        #将梯度设置归零
        optimizer.zero_grad()
        loss.backward()
        # w' = w - lr*grad
        optimizer.step()

        train_loss.append(loss.item())

        if batch_idx % 10==0:
            print(epoch, batch_idx, loss.item())

2.6 编写验证部分代码

#画出损失函数曲线
plot_curve(train_loss)
# we get optimal [w1, b1, w2, b2, w3, b3]

#验证部分代码
total_correct = 0
for x,y in test_loader:
    x  = x.view(x.size(0), 28*28)
    out = net(x)
    # out: [b, 10] => pred: [b]
    pred = out.argmax(dim=1)
    #统计预测正确的数量
    correct = pred.eq(y).sum().float().item()
    total_correct += correct

#统计正确率
total_num = len(test_loader.dataset)
acc = total_correct / total_num
print('test acc:', acc)

x, y = next(iter(test_loader))
out = net(x.view(x.size(0), 28*28))
pred = out.argmax(dim=1)
plot_image(x, pred, 'test')

 备注：utils工具类的代码

import torch
from matplotlib import pyplot as plt
from torch import nn

class Flatten(nn.Module):

    def __init__(self):
        super(Flatten, self).__init__()

    def forward(self, x):
        shape = torch.prod(torch.tensor(x.shape[1:])).item()
        return x.view(-1, shape)

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