【Pytorch学习笔记三】Pytorch神经网络包nn和优化器optm（一个简单的卷积神经网络模型的搭建）

nn构建于 Autograd之上，可用来定义和运行神经网络， PyTorch Autograd 让我们定义计算图和计算梯度变得容易了，但是原始的 Autograd 对于定义复杂的神经网络来说可能太底层了。

参考资料：
https://handbook.pytorch.wiki/chapter2/2.1.3-pytorch-basics-nerual-network.html

一， 神经网络包nn

torch.nn包括四个模块：

• nn.Parameter(Tensor子类，表示可学习参数如权重和偏置)

• nn.Module(所有模型的基类，可包含多个子 module，每个 module 都有 8 个字典管理自己的属性)

  nn.Module的容器：

  nn.Sequetial：顺序性，各网络层之间严格按照顺序执行，常用于 block 构建，在前向传播时的代码调用变得简洁

  nn.ModuleList：迭代行，常用于大量重复网络构建，通过 for 循环实现重复构建

  nn.ModuleDict：索引性，常用于可选择的网络层

• nn.functional(具体的函数实现，如卷积，此话，激活函数)

• nn.init(网络参数的初始化方法)，在下面的内容中均有体现。

1.1定义一个网络

PyTorch中已经为我们准备好了现成的网络模型，只要继承nn.Module，并实现它的forward方法，PyTorch会根据autograd，自动实现backward函数，在forward函数中可使用任何tensor支持的函数，还可以使用if、for循环、print、log等Python语法，写法和标准的Python写法一致。

1. 一个卷积层+一个全连接层的简单网络

创建模型包括：构建子模块和拼接子模块。如 LeNet 里包含很多卷积层、池化层、全连接层，当我们构建好所有的子模块之后，按照一定的顺序拼接起来。

import torch
import numpy as np
import torch.nn as nn
#新建一个Net类
class Net(nn.Module):
    def __init__(self):
        # nn.Module子类的函数必须在构造函数中执行父类的构造函数
        super(Net, self).__init__()
        ###构建子模块
        # 卷积层 '1'表示输入图片为单通道， '6'表示输出通道数，'3'表示卷积核为3*3
        self.conv1 = nn.Conv2d(1, 6, 3) 
        #线性层，输入1350个特征，输出10个特征
        self.fc1   = nn.Linear(1350, 10)  #这里的1350是如何计算的呢？这就要看后面的forward函数
    ###子模块拼接，正向传播 
    def forward(self, x): 
        print(x.size()) # 结果：[1, 1, 32, 32]
        # 卷积 -> 激活 -> 池化 
        x = self.conv1(x) #根据卷积的尺寸计算公式，计算结果是30
        x = F.relu(x) #relu非线性激活函数
        print(x.size()) # 结果：[1, 6, 30, 30]
        x = F.max_pool2d(x, (2, 2)) #我们使用池化层，计算结果是15
        x = F.relu(x)#relu非线性激活函数
        print(x.size()) # 结果：[1, 6, 15, 15]
        # reshape，‘-1’表示自适应
        #这里做的就是压扁的操作，就是把后面的[1, 6, 15, 15]压扁，变为 [1, 1350]
        x = x.view(x.size()[0], -1) 
        print(x.size()) # 这里就是fc1层的的输入1350 
        x = self.fc1(x)        
        return x

#实例化一个net
net = Net()
print(net) #打印网络结构

####运行结果####
Net(
 #次卷积层：'1'表示输入图片为单通道， '6'表示输出通道数，kernel_size卷积核大小，stride上下左右步长都为1
    (conv1): Conv2d(1, 6, kernel_size=(3, 3), stride=(1, 1))
 #全连接层   
  (fc1): Linear(in_features=1350, out_features=10, bias=True)
)

2. 查看网络学习参数：net.parameters() 或net.named_parameters（）

for name,parameters in net.named_parameters():
    print(name,':',parameters.size(),"\n",parameters)
    
####运行结果####
conv1.weight : torch.Size([6, 1, 3, 3]) # 卷积层的权重值：张量的大小
 Parameter containing: 
tensor([[[[-0.1015,  0.3081,  0.1869],
          [ 0.2470,  0.1662, -0.1575],
          [-0.2261,  0.0874,  0.2216]]],
                ...,
        [[[-0.1592,  0.1719, -0.2672],
          [-0.2361, -0.1751,  0.2658],
          [ 0.2580, -0.1811,  0.2160]]]], requires_grad=True)
conv1.bias : torch.Size([6]) 
Parameter containing:
tensor([-0.1991, -0.2411,  0.2407,  0.2796,  0.2808,  0.1946],
       requires_grad=True)
fc1.weight : torch.Size([10, 1350]) 
Parameter containing:
tensor([[-0.0049,  0.0079,  0.0190,  ..., -0.0029, -0.0144, -0.0015],
        [-0.0114, -0.0003, -0.0107,  ...,  0.0214,  0.0097, -0.0184],
        [ 0.0004, -0.0006, -0.0148,  ...,  0.0226, -0.0197, -0.0032],
        ...,
        [ 0.0213, -0.0106, -0.0120,  ..., -0.0012,  0.0217,  0.0201],
        [-0.0115,  0.0267, -0.0245,  ..., -0.0017,  0.0203,  0.0006],
        [ 0.0142, -0.0073,  0.0268,  ...,  0.0165, -0.0019, -0.0065]],
       requires_grad=True)
fc1.bias : torch.Size([10]) 
Parameter containing:
tensor([-0.0114,  0.0155,  0.0102, -0.0093, -0.0077, -0.0149, -0.0047,  0.0238,
        -0.0140,  0.0217], requires_grad=True)

3 网络输入及梯度清零

input = torch.randn(1, 1, 32, 32) # 随机化一个输入，大小是1*1*32*32，这里的对应前面forward的输入是32
out = net(input) #输入到网络中
out.size() #输出的大小
####运行结果####
中间层的维度
torch.Size([1, 1, 32, 32])
torch.Size([1, 6, 30, 30])
torch.Size([1, 6, 15, 15])
torch.Size([1, 1350])
#最后一层输出的大小
torch.Size([1, 10])

反向传播前，先要将所有参数的梯度清零。每次获取1个batch的数据，计算1次梯度，梯度不清空，不断累加，累加一定次数后，根据累加的梯度更新网络参数，然后清空梯度，进行下一次循环。所以，torch.nn只支持mini-batches，不支持一次只输入一个样本，即一次必须是一个batch。

net.zero_grad()  # 梯度清零，不清零上次结果会累加
out.backward(torch.ones(1,10)) # 反向传播的实现是PyTorch自动实现

1.2 损失函数

torch.nn中PyTorch还预制了常用的损失函数，下面我们用MSELoss用来计算均方误差。

y = torch.arange(0,10).view(1,10).float() #view()相当于reshape、resize，重新调整Tensor的形状。这里调整成1*10 ###view中一个参数定为-1，代表自动调整这个维度上的元素个数，以保证元素的总数不变。
criterion = nn.MSELoss() 
loss = criterion(out, y) #进行损失计算，loss是常量
print(loss.item())  # 打印损失值
####运行结果####
29.924724578857422

二、优化器

在反向传播计算完所有参数的梯度后，还需要使用优化方法来更新网络的权重和参数。在torch.optim中实现大多数的优化方法，例如：

**RMSProp（学习率角度）：**对参数的梯度使用了平方加权平均数，对学习率进行加权。

Adam（Adaptive Moment Estimation,自适应矩估计）：能够达到防止梯度的摆幅过大，同时加快收敛速度的作用。

随机梯度下降法（Stochastic gradient descent，SGD）：随机梯度下降算法是从样本中随机抽出一组，训练后按梯度更新一次，然后再抽取一组，再更新一次，在样本量极其大的况下，可能不用训练完所有的样本就可以获得一个损失值在可接受范围之内的模型了。

import torch.optim

#新建一个优化器，SGD只需要要调整的参数和学习率
optimizer = torch.optim.SGD(net.parameters(), lr = 0.01) #可以使用其他的优化器如Adam
#更新参数
optimizer.step()

一个神经网络完整的传播就已经通过PyTorch实现了。
未完待续！

欢迎关注个人微信公众号【智能建造小硕】（分享计算机编程、人工智能、智能建造、日常学习和科研经验等，欢迎大家关注交流。）