PyTorch-->神经网络

神经网络通过torch.nn包来重建。

神经网络基于自动梯度（autograd）来定义一些模型。一个nn.Module包括层和一个方法forward（input），会返回输出（output）。

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

1.定义一个包含可训练参数的神经网络

2.迭代整个输入

3.通过神经网络处理输入

4.计算损失（损失）

5.反向传播梯度到神经网络的参数

6.更新网络的参数，典型的用一个简单的更新方法：权重 = 权重 - 学习率 *梯度

定义神经网络：

class Net(nn.Module):

    def __init__(self):
        super(Net, self).__init__()
        # 1 input image channel, 6 output channels, 5*5 square conwolution
        # kernel
        self.conv1 = nn.Conv2d(1, 6, 5)  # 定义一个输入深度为1，输出为6，卷积核大小为 5*5 的 conv1 变量
        self.conv2 = nn.Conv2d(6, 16, 5)  # 输入通道数为6 输出通道数为16
        # an affine operation: y = Wx + b
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)  # 最终属于10类中的一个

    def forward(self, x):
        # 定义forward()函数：可以在此函数中使用任何Tensor操作
        # backward()函数被autograd自动定义
        # Max pooling over a (2,2) window
        # 输入x -> conv1 -> relu -> 2*2窗口的最大池化
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
        # If the size is a square you can only specify a single number
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
        # view 函数将张量x变形成一维向量形式，总特征数不变，为全连接层做准备
        x = x.view(-1, self.num_flat_features(x))
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(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

 输出如下：

注意：torch.nn 仅支持小批量样本输入，而不支持单个样本。例如，nn.Conv2d 接受一个 4D 张量 （nSamples x nChannels x Height x Width）。如果仅有一个样本输入，只需使用input.unsqueeze(0) 添加伪造的批次尺寸。

• 已经学到的：
• torch.Tensor - A multi-dimensional array with support for autograd operations like backward(). Also holds the gradient w.r.t. the tensor. 张量对象，支持autograd各种操作，记录梯度。
• nn.Module - Neural network module. Convenient way of encapsulating parameters, with helpers for moving them to GPU, exporting, loading, etc. 方便封装参数，可移植。
• nn.Parameter - A kind of Tensor, that is automatically registered as a parameter when assigned as an attribute to a Module. 一种张量，作为Module的属性时，自动登记参数。
• autograd.Function - Implements forward and backward definitions of an autograd operation. Every Tensor operation creates at least a single Function node that connects to functions that created a Tensor and encodes its history. 实现autograd 的 forward 和 backward函数。

损失函数：

以(output, target) 作为输入，计算一个值来评估output距离target有多远。例如：nn.MSELoss用于计算均方误差。

if __name__ == '__main__':
    net = Net()
    print(net)
    # 模型中可学习的参数通过net.parameters()返回
    params = list(net.parameters())
    print(len(params))
    print(params[0].size())  # conv1's.weight
    input = torch.randn(1, 1, 32, 32)  # try a random 32*32 input
    # It means expected input size of this net is 32*32.In order to use this net on MNIST dataset,resize the images
    #     from the dataset to 32*32.
    out = net(input)
    print(out)

    # # Zero the gradient buffers of all parameters and backprops with random gradients：利用随机梯度反向传播
    # net.zero_grad()
    # out.backward(torch.randn(1, 10))

    target = torch.randn(10)  # a dummy target
    target = target.view(1, -1)  # the same shape as output
    criterion = nn.MSELoss()

    loss = criterion(out, target)
    print(loss)

    print(loss.grad_fn)  # MSELoss
    print(loss.grad_fn.next_functions[0][0])  # Linear
    print(loss.grad_fn.next_functions[0][0].next_functions[0][0])  # ReLu
    # input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d
    #       -> view -> linear -> relu -> linear -> relu -> linear
    #       -> MSELoss
    #       -> loss

    # 使用损失函数进行反向传播
    # 只需要使用loss.backward(),但注意要清空现存的梯度，否则梯度会进行累加。
    # 调用loss.backward(), 查看con1的偏置项在反向传播之前和之后的变化
    net.zero_grad()
    print('before backward')
    print(net.conv1.bias.grad)  # 更新后由全0向量变为None
    loss.backward()
    print('after backward')
    print(net.conv1.bias.grad)

    # 更新神经网络参数(weight) rule:随机梯度下降
    learning_rate = 0.01
    for f in net.parameters():
        f.data.sub_(f.grad.data * learning_rate)  # weight = weight - learning_rate * gradient

    # more update rule:torch.optim  例如：SGD,Nesterov-SGD,Adam,RMSProp...
    import torch.optim as optim

    # create optimizer
    optimizer = optim.SGD(net.parameters(), lr=0.01)

    # in training loop:
    optimizer.zero_grad()  # zero the gradient buffers
    output = net(input)
    loss = criterion(output, target)
    loss.backward()
    optimizer.step()  # update