HaaS AI之VSCode中搭建Pytorch简单卷积神经网络

1、Pytorch简介

PyTorch是一个基于Torch的Python开源机器学习库，用于自然语言处理等应用程序。它主要由Facebook的人工智能小组开发，不仅能够实现强大的GPU加速，同时还支持动态神经网络，这一点是现在很多主流框架如TensorFlow都不支持的。 PyTorch提供了两个高级功能：

• 具有强大的GPU加速的张量计算（如Numpy）
• 包含自动求导系统的深度神经网络

PyTorch大量使用了Python概念，例如类、结构和条件循环，允许用户以纯面向对象的方式构建深度学习算法。

除了Facebook之外，Twitter、GMU和Salesforce等机构都采用了PyTorch，包括达摩院PAI平台也有使用。

2、Conda环境安装

参考https://yuque.antfin-inc.com/yoznxz/gin3ds/rgeb8g。

3、创建Pytorch Python虚拟环境

基于Python3.7版本，因此线创建一个PyTorch的Python虚拟环境。

conda create --name pytorch python=3.7

3.1 、激活环境

(tf2)$conda activate pytorch

3.2、安装PyTorch

访问官网https://pytorch.org/get-started/locally/

会根据当前系统提供合适的安装命令：

命令中包含安装视觉和声音两个部分，这里只安装视觉部分：

(pytorch)$conda install pytorch torchvision -c pytorch

3.3、安装Matplotlib

matplotlib，风格类似 Matlab 的基于 Python 的图表绘图系统。

matplotlib 是 Python最著名的绘图库，它提供了一整套和 matlab 相似的命 API，十分适合交互式地进行制图。而且也可以方便地将它作为绘图控件，嵌入 GUI 应用程序中，在模型训练中常常用来绘制图形。

（pytorch)$conda install matplotlib

4、PyTorch之初体验

4.1、Python环境配置

创建一个test.ipynb，并配置Python环境为pytorch虚拟环境。

4.2、Jupyter Kernel配置

在使用Jupyter时，需要连接到Jupyter kernel，按照下图选择Pytorch虚拟环境。

4.3、简单手写数字识别网络

在VSCode中使用Pytorch实现LeNet-5进行手写数字识别。

4.3.1、下载MNIST数据集

在PyTorch中，下载和导入MNIST数据集非常简单，可以使用torchvision库来完成。torchvision是一个专门进行图形处理的库，可加载比较常见的数据库，如ImageNet、CIFAR10、MNIST等。使用torchvision的好处是避免了重复编写数据集加载代码，让数据集的加载更加简单。

import torch
import torchvision
import torchvision.transforms as transforms
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import matplotlib.pyplot as plt
import numpy as np

#向量转换
transform = transforms.Compose([transforms.ToTensor()])

#训练集下载
trainset = torchvision.datasets.MNIST(
        root = './datasets/ch08/pytorch',
        train= True,
        download= True,
        transform=transform)

#测试集下载
testset = torchvision.datasets.MNIST(
        root='./datasets/ch08/pytorch',             # 选择数据的根目录
        train=False,
        download=True,                              # 从网络上下载图片
        transform=transform)

上面代码中参数root设置数据集在本地存放的目录，可自由选择。注意，对于训练集，参数train设置为True；对于测试集，参数train设置为False。关于参数download，如果是第一次运行该代码，则将其设置为True，表示从网络上下载MNIST数据集；如果已经下载了数据集，就可以将其设置为False。

4.3.2、加载数据集

#加载训练集
trainloader = torch.utils.data.DataLoader(
    trainset,
    batch_size = 4,
    shuffle = True,
    num_workers = 2)

#加载测试集
testloader = torch.utils.data.DataLoader(
    testset,
    batch_size=4,
    shuffle=False,
    num_workers=2)

上面代码中参数batch_size表示每个小批量样本集中的样本数量。参数shuffle表示是否在每个epoch中随机打乱数据集，这样做的目的是使每个epoch数据集的次序都不一样，保证每个小批量样本集尽可能不一样，提高接下来的训练效果。参数num_workers表示使用多少个子进程来导入数据。

print(trainset)
print(testset)

打印训练集和测试集路径：

Dataset MNIST
    Number of datapoints: 60000
    Root location: ./datasets/ch08/pytorch
    Split: Train
    StandardTransform
Transform: Compose(
               ToTensor()
           )
Dataset MNIST
    Number of datapoints: 10000
    Root location: ./datasets/ch08/pytorch
    Split: Test
    StandardTransform
Transform: Compose(
               ToTensor()
           )

4.3.3、显示训练集

def imshow(img):
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))

dataiter = iter(trainloader)
images, labels = dataiter.next()
imshow(torchvision.utils.make_grid(images))
plt.show()

print(' '.join('%11s' % labels[j].numpy() for j in range(4)))

显示训练集：

4.3.4、搭建LeNet-5网络模型

LeNet-5是卷积网络用于识别的开山之作，由被誉为“卷积网络之父”的Yann LeCun于1994年提出。虽然这网络结构现在已经很少使用，但是它对后续卷积网络的发展起到了奠基作用。这个网络虽然很小，但是它包含了深度学习的基本模块：卷积层，池化层，全连接层。是其他深度学习模型的基础。

同时，其中也体现了前述的设计思想：局部感受野、权值共享、下采样。  LeNet-5模型结构如下图:

搭建网络：

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        #第一层卷积
        self.conv1 = nn.Conv2d(1, 6, 5)         #1个输入图片通道, 6个输出通道, 5×5 卷积核
        #第一层池化层
        self.pool1 = nn.MaxPool2d(2, 2)         #max pooling, 2×2
        #第二层卷积
        self.conv2 = nn.Conv2d(6, 16, 5)        #6个输入图片通道, 16个输出通道, 5×5 卷积核
        #第二层池化
        self.pool2 = nn.MaxPool2d(2, 2)
        #全连接层
        self.fc1 = nn.Linear(16 * 4 * 4, 120)   #伸成一维向量
        #全连接层
        self.fc2 = nn.Linear(120, 84)           #120个特征图, 84个神经元
        #全连接层, 输出层
        self.fc3 = nn.Linear(84, 10)            #84个神经元输入, Softmax输出10个数字

    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = self.pool1(x)
        x = F.relu(self.conv2(x))
        x = self.pool2(x)
        #拉伸为一维向量
        x = x.view(-1, 16 * 4 * 4)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

MNIST图片的尺寸为28×28×1，经过第一层卷积层和池化层后，尺寸为:

28-5/1+4 = 24, 24/2 = 12

经过第二层卷积层和池化层后，尺寸为：

12-5/1+1 = 8, 8/2 = 4 由于该池化层滤波器组个数为16，则拉伸一维数组的长度就是1644。函数forward(self, x)定义了卷积神经网络的前向传播过程。

net = Net()
print(net)

打印网络：

Net(
  (conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))
  (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
  (pool2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (fc1): Linear(in_features=256, out_features=120, bias=True)
  (fc2): Linear(in_features=120, out_features=84, bias=True)
  (fc3): Linear(in_features=84, out_features=10, bias=True)
)

整个Net结构非常直观，可以完整、清晰地查看我们构建的卷积神经网络模型的结构。

4.3.5、模型优化

PyTorch中用nn.MSELoss表示均方差。 该项目是一个分类问题，所以损失函数使用交叉熵，PyTorch中用nn.CrossEntropyLoss表示交叉熵。如果是回归问题，损失函数一般使用均方差， 在卷积神经网络模型的反向传播中，仍然是基于梯度下降算法来优化参数的。

梯度优化算法同样可以应用到卷积神经网络模型中。使用方法非常简单，直接调用PyTorch中的torch.optim模块即可。例如，torch.optim. RMSprop表示RMSprop优化，torch.optim.Adam表示Adam优化。

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.parameters(), lr = 0.0001)   #梯度优化算法是Adam，学习率设置为0.0001

4.3.6、模型训练

每次迭代训练时都要先把所有梯度清零，即执行optimizer.zero_grad()。否则，梯度会累加，造成训练错误和失效。PyTorch中的.backward()可自动完成所有梯度计算。

num_epoches = 5                 #设置epoch 数目
cost = []                       #损失函数累
for epoch in range(num_epoches):
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data    #输入样本和标签
        optimizer.zero_grad()    #每次训练梯度清零

        # 正向传播、反向传播和优化过程
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
        if (i+1) % 2000 == 0:  # 每隔2000个小批量样本打印一次
            print('[epoch: %d, mini-batch: %5d] loss: %.3f' % 
            (epoch + 1, i + 1, running_loss / 2000))
            cost.append(running_loss / 2000)
            running_loss = 0.0

训练结果：

[epoch: 1, mini-batch:  2000] loss: 1.032
[epoch: 1, mini-batch:  4000] loss: 0.424
[epoch: 1, mini-batch:  6000] loss: 0.339
[epoch: 1, mini-batch:  8000] loss: 0.272
...
[epoch: 5, mini-batch: 10000] loss: 0.049
[epoch: 5, mini-batch: 12000] loss: 0.056
[epoch: 5, mini-batch: 14000] loss: 0.044

4.3.7、模型预测

训练集验证

correct = 0
total = 0
with torch.no_grad():
    for data in trainloader:
        images, labels = data
        outpus = net(images)
        _,predicted = torch.max(outpus.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
print('Accuracy on the 60000 train images: %.3f %%' % (100 * correct / total))

训练精度：

Accuracy on the 60000 train images: 98.352 %

测试集验证

correct = 0
total = 0
with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = net(images)
        _,predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
print('Accuracy on the 10000 test images: %.3f %%' % (100 * correct / total))

训练精度结果：

Accuracy on the 10000 test images: 98.370 %

4.3.8、测试代码

快速体验请直接下载完整测试代码 lenet5.ipynb

5、开发者技术支持

如需更多技术支持，可加入钉钉开发者群，或者关注微信公众号

更多技术与解决方案介绍，请访问阿里云AIoT首页https://iot.aliyun.com/