mseloss pytorch_PyTorch教程：神经网络-CSDN博客

本文翻译自Pytorch官方文档《DEEP LEARNING WITH PYTORCH: A 60 MINUTE BLITZ》

可以使用 torch.nn 包构建神经网络。

现在您已经了解了 autograd，nn 依靠 autograd 定义模型并对其进行区分。 nn.Module 包含图层，以及返回 output 的方法 forward(input)。

例如，查看以下对数字图像进行分类的网络：

convnet

这是一个简单的前馈网络。它获取输入，将其一层又一层地馈入，然后最终给出输出。

神经网络的典型训练过程如下：

定义具有一些可学习参数(或权重)的神经网络
遍历输入数据集
通过网络处理输入
计算损失(输出离正确有多远)
将梯度传播回网络参数
更新网络的权重，通常使用简单的更新规则：weight = weight - learning_rate * gradient

下面的图片来自 A Comprehensive Guide to Convolutional Neural Networks — the ELI5 way，能更清晰地展示整个网络。

定义网络

让我们定义这个网络

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个输入图片通道，6个输出通道，3x3 平方卷积核
        self.conv1 = nn.Conv2d(1, 6, 3)

        self.conv2 = nn.Conv2d(6, 16, 3)

# 仿射操作: y = Wx + b
        self.fc1 = nn.Linear(16 * 6 * 6, 120) # 图片维度 6*6
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

def forward(self, x):
# Max pooling over a (2, 2) window
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))

# 如果尺寸为正方形，则只能指定一个数字
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)

        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:]  # 除 batch 维度外的所有维度
        num_features = 1
for s in size:
            num_features *= s
return num_features

net = Net()
net

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

最大池化：Max pooling

池化(Pooling)是卷积神经网络中的一个重要概念，它实际上是一种非线性形式的降采样。最大池化(Max pooling)是将输入的图像划分为若干个矩形区域，对每个子区域输出最大值。

线性整流：Rectified Linear Units, ReLU

线性整流层使用线性整流 f(x) = max(0, x) 作为这一层神经的激励函数(Activation function)。它可以增强判定函数和整个神经网络的非线性特性，而本身并不会改变卷积层。

引自维基百科 卷积神经网络

您只需要定义 forward 函数，就可以使用 autograd 为您自动定义 backward 函数(计算梯度)。您可以在 forward函数中使用任何 Tensor 操作。

net.parameters() 返回模型的可学习参数

params = list(net.parameters())
print(len(params))
print(params[0].size()) # conv1 的 .weight

10
torch.Size([6, 1, 3, 3])

让我们尝试 32x32 随机输入。注意：该网络(LeNet)的预期输入大小为 32x32。要在 MNIST 数据集上使用此网络，请将数据集中的图像调整为 32x32。

input = torch.randn(1, 1, 32, 32)
out = net(input)
out

tensor([[ 0.0016, -0.0051, -0.0208, -0.0015, -0.0422, -0.0511, -0.0886,  0.0619,
         -0.1105, -0.0016]], grad_fn=)

将所有参数的梯度缓冲区归零，并用随机的梯度后向传播：

net.zero_grad()
out.backward(torch.randn(1, 10))

注意

torch.nn 仅支持微型批次(mini-batches)。整个 torch.nn 封装仅支持小批次样本的输入，而不是单个样本。

例如，nn.Conv2d 将接收 nSamples x nChannels x Height x Width 的 4D Tensor。

如果您有单个样本，只需使用 input.unsqueeze(0) 添加假批次维度即可。

在继续之前，让我们回顾一下到目前为止所看到的所有类。

Recap

torch.Tensor：一个多维数组，支持诸如 backward() 之类的 autograd 操作。还保留了 w.r.t. tensor。
nn.Module：神经网络模块。方便的封装参数的方式，并带有将其移动到 GPU，导出，加载等的帮助器。
nn.Parameter：一种 Tensor，当作为属性分配给 Module 时会 自动注册 为参数。
autograd.Function：实现 autograd 操作的 前向和后向定义 。每个 Tensor 操作都会创建至少一个 Function 节点，该节点连接到创建 Tensor 并对其历史进行编码的函数。

至此，我们介绍了：

定义神经网络
处理输入和后向调用

尚未介绍：

计算损失
更新网络的权重

损失函数

损失函数采用(输出、目标)输入对，并计算估计输出与目标距离的值。

nn 包下有几个不同的损失函数。一个简单的损失是：nn.MSELoss，它计算输入和目标之间的均方误差。

https://pytorch.org/docs/nn.html#loss-functions

例如：

output = net(input)
target = torch.randn(10)
target = target.view(1, -1)
criterion = nn.MSELoss()

loss = criterion(output, target)
loss

tensor(0.5839, grad_fn=)

现在，如果使用 .grad_fn 属性以反向跟踪 loss，您将看到一个计算图，如下所示：

input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d
      -> view -> linear -> relu -> linear -> relu -> linear
      -> MSELoss
      -> loss

因此，当我们调用 loss.backward() 时，整个图在损耗方面是有区别的。并且图表中所有具有 require_grad=True 的 Tensor 将随梯度累积其 .grad Tensor。

为了说明，让我们向后走几步：

print(loss.grad_fn) # MELoss
print(loss.grad_fn.next_functions[0][0]) # linear
print(loss.grad_fn.next_functions[0][0].next_functions[0][0]) # ReLU

反向传播(Backprop)

要反向传播误差，我们要做的就是 loss.backward()。不过，您需要清除现有的梯度，否则梯度将累积到现有的梯度中。

现在，我们将调用 loss.backward()，并了解 conv1 反向传播之前和之后的偏差梯度。

net.zero_grad()  # 将所有参数的梯度缓冲区归零

print("conv1.bias.grad before backward")
print(net.conv1.bias.grad)

loss.backward()

print("conv1.bias.grad after backward")
print(net.conv1.bias.grad)

conv1.bias.grad before backward
tensor([0., 0., 0., 0., 0., 0.])
conv1.bias.grad after backward
tensor([ 0.0126,  0.0097,  0.0075,  0.0054, -0.0106, -0.0077])

现在，我们已经看到了如何使用损失函数。

扩展阅读

神经网络软件包包含各种模块和损失函数，这些模块和损失函数构成了深度神经网络的构建块。完整的文档清单在这里。

https://pytorch.org/docs/nn

唯一需要学习的是：

更新网络的权重

更新权重

实践中使用的最简单的更新规则是随机梯度下降(SGD)：

weight = weight - learning_rate * gradient

我们可以使用简单的 Python 代码实现：

learning_rate = 0.01
for f in net.parameters():
    f.data.sub_(f.grad.data * learning_rate)

但是，当您使用神经网络时，您希望使用各种不同的更新规则，如 SGD、Nesterov-SGD、Adam、RMSProp 等。为了实现这一点，我们构建了一个小包：torch.optim，用于实现所有这些方法。使用它非常简单：

import torch.optim as optim

# 创建优化器
optimizer = optim.SGD(net.parameters(), lr=0.01)

# 在训练循环中
optimizer.zero_grad()  # 梯度缓存清零
output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step()  # 执行更新

注意

观察如何使用 optimizer.zero_grad() 将梯度缓冲区手动设置为零。这是因为梯度会累积，如“反向传播”部分中所述。

参考

https://github.com/pytorch/tutorials

https://pytorch.org/tutorials/beginner/blitz/neural_networks_tutorial.html

https://towardsdatascience.com/a-comprehensive-guide-to-convolutional-neural-networks-the-eli5-way-3bd2b1164a53

https://zh.wikipedia.org/wiki/%E5%8D%B7%E7%A7%AF%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C

PyTorch教程

PyTorch教程：什么是PyTorch

PyTorch教程：autograd - 自动微分

题图由 Pexels 在 Pixabay 上发布。