【580】PyTorch 实现 CNN 例子（模型构建+训练方法）

参考：PyTorch 神经网络

参考：PyTorch 图像分类器

参考：深度学习框架Keras与Pytorch对比

参考：最浅显易懂的 PyTorch 深度学习入门 —— Bilibili

---

 

　　实现下面这个网络：

 

• 第一层：卷积 5*5*6、ReLU、Max Pooling
• 第二层：卷积 5*5*16、ReLU、Max Pooling
• 第三层：Flatten、Linear NN
• 第四层：Linear NN
• 第五层：Linear NN　　

　　这是一个简单的前馈神经网络，它接收输入，让输入一个接着一个的通过一些层，最后给出输出。

一个典型的神经网络训练过程包括以下几点：

1. 定义一个包含可训练参数的神经网络
2. 迭代整个输入
3. 通过神经网络处理输入
4. 计算损失(loss)
5. 反向传播梯度到神经网络的参数
6. 更新网络的参数，典型的用一个简单的更新方法：weight = weight - learning_rate *gradient

定义神经网络：

import torch 
import torch.nn as nn 
import torch.nn.functional as F 

class Net(nn.Module):
    def __init__(  self ):
        super (Net,   self ).__init__()
        # 1 input image channel, 6 output channels, 5x5 square convolution kernel
        # 第一层
        self .conv1   = nn.Conv2d(in_channels  = 1 , out_channels  = 6 , kernel_size  = 5 )
        # 第二层
        self .conv2   = nn.Conv2d(in_channels  = 6 , out_channels  = 16 , kernel_size  = 5 )
        # an affine operation: y = Wx + b
        # 第三层
        self .fc1   = nn.Linear(in_features  = 16 * 5 * 5 , out_features  = 120 )
        # 第四层
        self .fc2   = nn.Linear(in_features  = 120 , out_features  = 84 )
        # 第五层
        self .fc3   = nn.Linear(in_features  = 84 , out_features  = 10 )
      
    def forward(  self , x):
        # 第一层 (conv1 -> relu -> max pooling)
        x   = self .conv1(x)
        x   = F.relu(x)
        # Max pooling over a (2, 2) window
        x   = F.max_pool2d(x, (  2 ,   2 ))
      
        # 第二层 (conv2 -> relu -> max pooling)
        x   = self .conv2(x)
        x   = F.relu(x)
        # If the size is a square you can only specify a single number
        x   = F.max_pool2d(x,   2 )
      
        # 第三层 (fc -> relu)
        x   = x.view(  - 1 ,   self .num_flat_features(x))
        x   = self .fc1(x)
        x   = F.relu(x) 
      
        # 第四层 (fc -> relu)
        x   = self .fc2(x)
        x   = F.relu(x)
      
        # 第五层 (fc -> relu)
        x   = self .fc3(x)
        x   = F.relu(x) 
      
        return x 
      
    def num_flat_features(  self , x):
        size   = x.size()[  1 :]    # all dimensions except the batch dimension
        num_features   = 1
        for s   in size:
            num_features   * = s
        return num_features
  
net   = Net()
print (net)

　　输出：

Net(
  (conv1): Conv2d(  1 ,   6 , kernel_size  = (  5 ,   5 ), stride  = (  1 ,   1 ))
  (conv2): Conv2d(  6 ,   16 , kernel_size  = (  5 ,   5 ), stride  = (  1 ,   1 ))
  (fc1): Linear(in_features  = 400 , 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 )
)

在Pytorch中训练模型包括以下几个步骤:

1. 在每批训练开始时初始化梯度
2. 前向传播
3. 反向传播
4. 计算损失并更新权重

import torch.optim as optim

criterion    = nn.CrossEntropyLoss()
optimizer    = optim.SGD(net.parameters(), lr   = 0.001 , momentum   = 0.9 )

for epoch    in range (   2 ):     # loop over the dataset multiple times

    running_loss    = 0.0
    for i, data    in enumerate (trainloader,    0 ):
        # get the inputs
        inputs, labels    = data

        # zero the parameter gradients
        optimizer.zero_grad()   # Make sure gradient does not accumulate

        # forward + backward + optimize
        outputs    = net(inputs)
        loss    = criterion(outputs, labels)
        loss.backward()   # Compute gradient
        optimizer.step()   # Update NN weights

        # print statistics
        running_loss    + = loss.item()
        if i    % 2000 = = 1999 :       # print every 2000 mini-batches
            print (   '[%d, %5d] loss: %.3f' %
                  (epoch    + 1 , i    + 1 , running_loss    / 2000 ))
            running_loss    = 0.0

print (   'Finished Training' ) 

　　通用

# 在数据集上循环多次
for epoch    in range (   2 ):  
    for i, data    in enumerate (trainloader,    0 ):
        # 获取输入; data是列表[inputs, labels]
        inputs, labels    = data 
        # (1) 初始化梯度
        optimizer.zero_grad()   # Make sure gradient does not accumulate

        # (2) 前向传播
        outputs    = net(inputs)
        loss    = criterion(outputs, labels)

        # (3) 反向传播
        loss.backward()   # Compute gradient
        # (4) 计算损失并更新权重
        optimizer.step()   # Update NN weights

结果可视化