神经网络可以使用torch.nn包来构建。 现在你大致了解了autograd，nn依赖于autograd来定义模型并进行求导。一个nn.Module包含多个神经网络层，以及一个forward(input)方法来返回output。

例如，看看以下这个分类数字图像的网络：

[attach]14[/attach]

它是一个简单的前馈网络。它将输入逐步地喂给多个层，然后给出输出。

一个典型的神经网络训练过程如下： [list] []定义一个拥有可学习参数（或权重）的神经网络[/] []在输入数据上进行迭代[/] []在网络中处理数据[/] []计算损失（输出离分类正确有多远）[/] []梯度反向传播给网络的参数[/] []更新网络的权重，通常使用一个简单的更新规则：weight = weight + learning_rate gradient[/*] [/list] [quote] [b]定义网络[/b] [/quote] [code]import torch from torch.autograd import Variable import torch.nn as nn import torch.nn.functional as F

class Net(nn.Module):

def __init__(self):
    super(Net, self).__init__()
    # 1 图像输入通道, 6 输出通道, 5x5 正方形卷积核
    self.conv1 = nn.Conv2d(1, 6, 5)
    self.conv2 = nn.Conv2d(6, 16, 5)
    # 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)

def forward(self, x):
    # 使用 (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)
    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:]   # 所有维度，除了批尺寸
    num_features = 1
    for s in size:
        num_features *= s
    return num_features

net = Net() print(net)[/code]输出：[code]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 (400 -> 120) (fc2): Linear (120 -> 84) (fc3): Linear (84 -> 10) )[/code] 你只需要定义forward函数，backward函数（用来计算梯度）是使用autograd自动为你定义的。你可以在forward中使用任意的Tensor运算操作。

模型中可学习的参数是通过net.parameters()返回的：[code]params = list(net.parameters()) print(len(params)) print(params[0].size()) # conv1's .weight[/code]输出：[code]10 torch.Size([6, 1, 5, 5])[/code]forward的输入是一个autograd.Variable ，输出亦然。[code]input = Variable(torch.randn(1, 1, 32, 32)) out = net(input) print(out)[/code]输出：[code]Variable containing: 0.0455 -0.0445 0.0064 -0.0310 0.0945 -0.0362 -0.1971 0.0555 0.0943 0.1016 [torch.FloatTensor of size 1x10][/code]将梯度缓冲区置0，并使用随机的梯度进行反向传播：[code]net.zero_grad() out.backward(torch.randn(1, 10))[/code] [quote] [b]注意：[/b] torch.nn仅支持mini-batch。整个的torch.nn包仅支持小批量的数据，而不是一个单独的样本。 例如，nn.Conv2d应传入一个4D的Tensor，维度为nSamples x nChannels x Height x Width。 如果你有一个单独的样本，使用input.unsqueeze(0)来添加一个伪批维度。 在继续之前，我们先回顾一下迄今为止的所有课程。 [/quote]

[b]回顾总结：[/b] [list] []torch.Tensor 一个多维数组[/] []autograd.Variable 包装一个Tensor并且记录应用在其上的历史运算操作。拥有与Tensor相同的API，添加了一些像backward()的操作。还包括相关tensor的梯度。[/] []nn.Module 神经网络模块。封装参数的方便方式，带有将它们转移到GPU、导出、载入等的帮助函数。[/] []nn.Parameter 一种Variable，当给Module赋值时自动注册一个参数。[/] []autograd.Function 实现一个autograd 操作的 forward 和 backward 定义。每一个Variable操作，创建至少一个Function节点，来连接那些创建Variable的函数，并且记录其历史。[/] [/list] 在这里，我们涵盖了： [list] []定义神经网络[/] []处理输入并调用backward[/] [/list] 还剩下： [list] []计算损失[/] []更新网络权重[/] [/list] [quote] [b]损失函数[/b] [/quote]

一个损失函数以一个(output, target)对为输入，然后计算一个值用以估计输出结果离目标结果多远。 存在多种的损失函数。一个简单的损失函数：nn.MSELoss，它计算输出与目标的均方误差。

例如：[code]output = net(input) target = Variable(torch.arange(1, 11)) # a dummy target, for example criterion = nn.MSELoss()

loss = criterion(output, target) print(loss)[/code]输出：[code]Variable containing: 38.3005 [torch.FloatTensor of size 1][/code]现在，如果你在反方向跟随loss，使用它的.creator属性，你会看到一个如下所示的计算图：[code]input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d -> view -> linear -> relu -> linear -> relu -> linear -> MSELoss -> loss[/code]因此，当我们调用loss.backward()时，损失对应的整个图都被求导，并且图中所有的变量都会带有累积了梯度的.grad属性。[code]print(loss.creator) # MSELoss print(loss.creator.previous_functions[0][0]) # linear print(loss.creator.previous_functions[0][0].previous_functions[0][0]) # ReLU[/code] 输出：[code]<torch.nn._functions.thnn.auto.MSELoss object at 0x10e0bdd68> <torch.nn._functions.linear.Linear object at 0x10e0bdba8> <torch.nn._functions.thnn.auto.Threshold object at 0x10e0bdac8>[/code] 反向传播

要进行反向传播，我们只需要调用loss.backward()。你需要清除现有的梯度，否则梯度将累积到现有梯度。

现在我们将调用loss.backward()，并看看conv1在backward之前和之后的梯度变化。[code]net.zero_grad() # zeroes the gradient buffers of all parameters

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

loss.backward()

print('conv1.bias.grad after backward') print(net.conv1.bias.grad)[/code] 输出：[code]conv1.bias.grad before backward Variable containing: 0 0 0 0 0 0 [torch.FloatTensor of size 6]

conv1.bias.grad after backward Variable containing: 0.1392 -0.1155 0.0247 0.1121 -0.0559 0.0363 [torch.FloatTensor of size 6][/code] 现在我们知道怎么使用损失函数了。

延伸阅读

神经网络包包含构建深度神经网络的多个模块和损失函数。一个完整的文档列表在这里

仅剩的一个要学习的东西： [list] []更新网络权重[/] [/list] [quote] [b]更新权重[/b] [/quote]

实践中最简单的更新规则是随机梯度下降（SGD）：[code]weight = weight - learning_rate gradient[/code] 我们可以使用简单的Python代码实现：[code]learningrate = 0.01 for f in net.parameters(): f.data.sub(f.grad.data learning_rate)[/code] 然而，当您使用神经网络时，您希望使用各种不同的更新规则，例如SGD，Nesterov-SGD，Adam，RMSProp等等。为了实现这一点，我们构建一个小的包：torch.optim，来实现所有的方法。使用非常简单：[code]import torch.optim as optim

create your optimizer

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

in your training loop:

optimizer.zero_grad() # zero the gradient buffers output = net(input) loss = criterion(output, target) loss.backward() optimizer.step() # Does the update[/code]