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

2021-03-01 10:02 341人阅读评论(0)

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/

转载：https://blog.csdn.net/HaaSTech/article/details/113587646

查看评论

飞道的博客