用例子学习 PyTorch

译者：bat67

最新版会在译者仓库首先同步。

作者：Justin Johnson

这个教程通过自洽的示例介绍了PyTorch的基本概念。

PyTorch主要是提供了两个核心的功能特性：

  • 一个类似于numpy的n维张量，但是可以在GPU上运行
  • 搭建和训练神经网络时的自动微分/求导机制

我们将使用全连接的ReLU网络作为运行示例。该网络将有一个单一的隐藏层，并将使用梯度下降训练，通过最小化网络输出和真正结果的欧几里得距离，来拟合随机生成的数据。

目录

张量

Warm-up：NumPy

在介绍PyTorch之前，我们将首先使用NumPy实现网络。

NumPy提供了一个n维数组对象和许多用于操作这些数组的函数。NumPy是用于科学计算的通用框架；它对计算图、深度学习和梯度一无所知。然而，我们可以很容易地使用NumPy，手动实现网络的前向和反向传播，来拟合随机数据：

  1. # 可运行代码见本文件夹中的 two_layer_net_numpy.py
  2. import numpy as np
  4. # N是批大小；D_in是输入维度
  5. # H是隐藏层维度；D_out是输出维度  
  6. N, D_in, H, D_out = 64, 1000, 100, 10
  8. # 产生随机输入和输出数据
  9. x = np.random.randn(N, D_in)
  10. y = np.random.randn(N, D_out)
  12. # 随机初始化权重
  13. w1 = np.random.randn(D_in, H)
  14. w2 = np.random.randn(H, D_out)
  16. learning_rate = 1e-6
  17. for t in range(500):
  18.     # 前向传播：计算预测值y
  19.     h = x.dot(w1)
  20.     h_relu = np.maximum(h, 0)
  21.     y_pred = h_relu.dot(w2)
  23.     # 计算并显示loss(损失）
  24.     loss = np.square(y_pred - y).sum()
  25.     print(t, loss)
  27.     # 反向传播，计算w1、w2对loss的梯度
  28.     grad_y_pred = 2.0 * (y_pred - y)
  29.     grad_w2 = h_relu.T.dot(grad_y_pred)
  30.     grad_h_relu = grad_y_pred.dot(w2.T)
  31.     grad_h = grad_h_relu.copy()
  32.     grad_h[h < 0] = 0
  33.     grad_w1 = x.T.dot(grad_h)
  35.     # 更新权重
  36.     w1 -= learning_rate * grad_w1
  37.     w2 -= learning_rate * grad_w2

PyTorch：张量

NumPy是一个很棒的框架，但是它不支持GPU以加速运算。现代深度神经网络，GPU常常提供50倍以上的加速)，所以NumPy不能满足当代深度学习的需求。

我们先介绍PyTorch最基础的概念：张量(Tensor）。逻辑上，PyTorch的tensor和NumPy array是一样的：tensor是一个n维数组，PyTorch提供了很多函数操作这些tensor。任何希望使用NumPy执行的计算也可以使用PyTorch的tensor来完成；可以认为它们是科学计算的通用工具。

和NumPy不同的是，PyTorch可以利用GPU加速。要在GPU上运行PyTorch张量，在构造张量使用device参数把tensor建立在GPU上。

这里我们利用PyTorch的tensor在随机数据上训练一个两层的网络。和前面NumPy的例子类似，我们使用PyTorch的tensor，手动在网络中实现前向传播和反向传播： 

  1. # 可运行代码见本文件夹中的 two_layer_net_tensor.py
  2. import torch
  4. device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') 
  6. # N是批大小； D_in 是输入维度；
  7. # H 是隐藏层维度； D_out 是输出维度
  8. N, D_in, H, D_out = 64, 1000, 100, 10
  10. # 产生随机输入和输出数据
  11. x = torch.randn(N, D_in, device=device)
  12. y = torch.randn(N, D_out, device=device)
  14. # 随机初始化权重
  15. w1 = torch.randn(D_in, H, device=device)
  16. w2 = torch.randn(H, D_out, device=device)
  18. learning_rate = 1e-6
  19. for t in range(500):
  20.     # 前向传播：计算预测值y
  21.     h = x.mm(w1)
  22.     h_relu = h.clamp(min=0)
  23.     y_pred = h_relu.mm(w2)
  25.     # 计算并输出loss；loss是存储在PyTorch的tensor中的标量，维度是()(零维标量）；
  26.     # 我们使用loss.item()得到tensor中的纯python数值。
  27.     loss = (y_pred - y).pow(2).sum()
  28.     print(t, loss.item())
  30.     # 反向传播，计算w1、w2对loss的梯度
  31.     grad_y_pred = 2.0 * (y_pred - y)
  32.     grad_w2 = h_relu.t().mm(grad_y_pred)
  33.     grad_h_relu = grad_y_pred.mm(w2.t())
  34.     grad_h = grad_h_relu.clone()
  35.     grad_h[h < 0] = 0
  36.     grad_w1 = x.t().mm(grad_h)
  38.     # 使用梯度下降更新权重
  39.     w1 -= learning_rate * grad_w1
  40.     w2 -= learning_rate * grad_w2

自动求导

PyTorch：张量和自动求导

在上面的例子里，需要我们手动实现神经网络的前向和后向传播。对于简单的两层网络，手动实现前向、后向传播不是什么难事，但是对于大型的复杂网络就比较麻烦了。

庆幸的是，我们可以使用自动微分来自动完成神经网络中反向传播的计算。PyTorch中autograd包提供的正是这个功能。当使用autograd时，网络前向传播将定义一个计算图；图中的节点是tensor，边是函数，这些函数是输出tensor到输入tensor的映射。这张计算图使得在网络中反向传播时梯度的计算十分简单。

这听起来复杂，但是实际操作很简单。如果我们想计算某些的tensor的梯度，我们只需要在建立这个tensor时加入这么一句：requires_grad=True。这个tensor上的任何PyTorch的操作都将构造一个计算图，从而允许我们稍后在图中执行反向传播。如果这个tensorx的requires_grad=True，那么反向传播之后x.grad将会是另一个张量，其为x关于某个标量值的梯度。

有时可能希望防止PyTorch在requires_grad=True的张量执行某些操作时构建计算图；例如，在训练神经网络时，我们通常不希望通过权重更新步骤进行反向传播。在这种情况下，我们可以使用torch.no_grad()上下文管理器来防止构造计算图。

下面我们使用PyTorch的Tensors和autograd来实现我们的两层的神经网络；我们不再需要手动执行网络的反向传播：

  1. # 可运行代码见本文件夹中的 two_layer_net_autograd.py
  2. import torch
  4. device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') 
  6. # N是批大小；D_in是输入维度；
  7. # H是隐藏层维度；D_out是输出维度  
  8. N, D_in, H, D_out = 64, 1000, 100, 10
  10. # 产生随机输入和输出数据
  11. x = torch.randn(N, D_in, device=device)
  12. y = torch.randn(N, D_out, device=device)
  14. # 产生随机权重tensor，将requires_grad设置为True意味着我们希望在反向传播时候计算这些值的梯度
  15. w1 = torch.randn(D_in, H, device=device, requires_grad=True)
  16. w2 = torch.randn(H, D_out, device=device, requires_grad=True)
  18. learning_rate = 1e-6
  19. for t in range(500):
  21.     # 前向传播：使用tensor的操作计算预测值y。
  22.     # 由于w1和w2有requires_grad=True，涉及这些张量的操作将让PyTorch构建计算图，
  23.     # 从而允许自动计算梯度。由于我们不再手工实现反向传播，所以不需要保留中间值的引用。
  24.     y_pred = x.mm(w1).clamp(min=0).mm(w2)
  26.     # 计算并输出loss，loss是一个形状为()的张量，loss.item()是这个张量对应的python数值
  27.     loss = (y_pred - y).pow(2).sum()
  28.     print(t, loss.item())
  30.     # 使用autograd计算反向传播。这个调用将计算loss对所有requires_grad=True的tensor的梯度。
  31.     # 这次调用后，w1.grad和w2.grad将分别是loss对w1和w2的梯度张量。
  32.     loss.backward()
  35.     # 使用梯度下降更新权重。对于这一步，我们只想对w1和w2的值进行原地改变；不想为更新阶段构建计算图，
  36.     # 所以我们使用torch.no_grad()上下文管理器防止PyTorch为更新构建计算图
  37.     with torch.no_grad():
  38.         w1 -= learning_rate * w1.grad
  39.         w2 -= learning_rate * w2.grad
  41.         # 反向传播之后手动置零梯度
  42.         w1.grad.zero_()
  43.         w2.grad.zero_()

PyTorch：定义新的自动求导函数

在底层，每一个原始的自动求导运算实际上是两个在Tensor上运行的函数。其中，forward函数计算从输入Tensors获得的输出Tensors。而backward函数接收输出Tensors对于某个标量值的梯度，并且计算输入Tensors相对于该相同标量值的梯度。

在PyTorch中，我们可以很容易地通过定义torch.autograd.Function的子类并实现forward和backward函数，来定义自己的自动求导运算。之后我们就可以使用这个新的自动梯度运算符了。然后，我们可以通过构造一个实例并像调用函数一样，传入包含输入数据的tensor调用它，这样来使用新的自动求导运算。

这个例子中，我们自定义一个自动求导函数来展示ReLU的非线性。并用它实现我们的两层网络：

  1. # 可运行代码见本文件夹中的 two_layer_net_custom_function.py
  2. import torch
  4. class MyReLU(torch.autograd.Function):
  5.     """
  6.     我们可以通过建立torch.autograd的子类来实现我们自定义的autograd函数，
  7.     并完成张量的正向和反向传播。
  8.     """
  9.     @staticmethod
  10.     def forward(ctx, x):
  11.         """
  12.         在正向传播中，我们接收到一个上下文对象和一个包含输入的张量；
  13.         我们必须返回一个包含输出的张量，
  14.         并且我们可以使用上下文对象来缓存对象，以便在反向传播中使用。
  15.         """
  16.         ctx.save_for_backward(x)
  17.         return x.clamp(min=0)
  19.     @staticmethod
  20.     def backward(ctx, grad_output):
  21.         """
  22.         在反向传播中，我们接收到上下文对象和一个张量，
  23.         其包含了相对于正向传播过程中产生的输出的损失的梯度。
  24.         我们可以从上下文对象中检索缓存的数据，
  25.         并且必须计算并返回与正向传播的输入相关的损失的梯度。
  26.         """
  27.         x, = ctx.saved_tensors
  28.         grad_x = grad_output.clone()
  29.         grad_x[x < 0] = 0
  30.         return grad_x
  33. device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
  35. # N是批大小； D_in 是输入维度；
  36. # H 是隐藏层维度； D_out 是输出维度
  37. N, D_in, H, D_out = 64, 1000, 100, 10
  39. # 产生输入和输出的随机张量
  40. x = torch.randn(N, D_in, device=device)
  41. y = torch.randn(N, D_out, device=device)
  43. # 产生随机权重的张量
  44. w1 = torch.randn(D_in, H, device=device, requires_grad=True)
  45. w2 = torch.randn(H, D_out, device=device, requires_grad=True)
  47. learning_rate = 1e-6
  48. for t in range(500):
  49.     # 正向传播：使用张量上的操作来计算输出值y；
  50.     # 我们通过调用 MyReLU.apply 函数来使用自定义的ReLU
  51.     y_pred = MyReLU.apply(x.mm(w1)).mm(w2)
  53.     # 计算并输出loss
  54.     loss = (y_pred - y).pow(2).sum()
  55.     print(t, loss.item())
  57.     # 使用autograd计算反向传播过程。
  58.     loss.backward()
  60.     with torch.no_grad():
  61.         # 用梯度下降更新权重
  62.         w1 -= learning_rate * w1.grad
  63.         w2 -= learning_rate * w2.grad
  65.         # 在反向传播之后手动清零梯度
  66.         w1.grad.zero_()
  67.         w2.grad.zero_()

TensorFlow：静态图

PyTorch自动求导看起来非常像TensorFlow：这两个框架中，我们都定义计算图，使用自动微分来计算梯度。两者最大的不同就是TensorFlow的计算图是静态的，而PyTorch使用动态的计算图。

在TensorFlow中，我们定义计算图一次，然后重复执行这个相同的图，可能会提供不同的输入数据。而在PyTorch中，每一个前向通道定义一个新的计算图。

静态图的好处在于你可以预先对图进行优化。例如，一个框架可能要融合一些图的运算来提升效率，或者产生一个策略来将图分布到多个GPU或机器上。如果重复使用相同的图，那么在重复运行同一个图时，，前期潜在的代价高昂的预先优化的消耗就会被分摊开。

静态图和动态图的一个区别是控制流。对于一些模型，我们希望对每个数据点执行不同的计算。例如，一个递归神经网络可能对于每个数据点执行不同的时间步数，这个展开(unrolling）可以作为一个循环来实现。对于一个静态图，循环结构要作为图的一部分。因此，TensorFlow提供了运算符(例如tf.scan）来把循环嵌入到图当中。对于动态图来说，情况更加简单：既然我们为每个例子即时创建图，我们可以使用普通的命令式控制流来为每个输入执行不同的计算。

为了与上面的PyTorch自动梯度实例做对比，我们使用TensorFlow来拟合一个简单的2层网络：

  1. # 可运行代码见本文件夹中的 tf_two_layer_net.py
  2. import tensorflow as tf
  3. import numpy as np
  5. # 首先我们建立计算图(computational graph）
  7. # N是批大小；D是输入维度；
  8. # H是隐藏层维度；D_out是输出维度。
  9. N, D_in, H, D_out = 64, 1000, 100, 10
  11. # 为输入和目标数据创建placeholder；
  12. # 当执行计算图时，他们将会被真实的数据填充
  13. x = tf.placeholder(tf.float32, shape=(None, D_in))
  14. y = tf.placeholder(tf.float32, shape=(None, D_out))
  16. # 为权重创建Variable并用随机数据初始化
  17. # TensorFlow的Variable在执行计算图时不会改变
  18. w1 = tf.Variable(tf.random_normal((D_in, H)))
  19. w2 = tf.Variable(tf.random_normal((H, D_out)))
  21. # 前向传播：使用TensorFlow的张量运算计算预测值y。
  22. # 注意这段代码实际上不执行任何数值运算；
  23. # 它只是建立了我们稍后将执行的计算图。
  24. h = tf.matmul(x, w1)
  25. h_relu = tf.maximum(h, tf.zeros(1))
  26. y_pred = tf.matmul(h_relu, w2)
  28. # 使用TensorFlow的张量运算损失(loss）
  29. loss = tf.reduce_sum((y - y_pred) ** 2.0)
  31. # 计算loss对于w1和w2的导数
  32. grad_w1, grad_w2 = tf.gradients(loss, [w1, w2])
  34. # 使用梯度下降更新权重。为了实际更新权重，我们需要在执行计算图时计算new_w1和new_w2。
  35. # 注意，在TensorFlow中，更新权重值的行为是计算图的一部分;
  36. # 但在PyTorch中，这发生在计算图形之外。
  37. learning_rate = 1e-6
  38. new_w1 = w1.assign(w1 - learning_rate * grad_w1)
  39. new_w2 = w2.assign(w2 - learning_rate * grad_w2)
  41. # 现在我们搭建好了计算图，所以我们开始一个TensorFlow的会话(session）来实际执行计算图。
  42. with tf.Session() as sess:
  44.     # 运行一次计算图来初始化Variable w1和w2
  45.     sess.run(tf.global_variables_initializer())
  47.     # 创建numpy数组来存储输入x和目标y的实际数据
  48.     x_value = np.random.randn(N, D_in)
  49.     y_value = np.random.randn(N, D_out)
  51.     for _ in range(500):
  52.         # 多次运行计算图。每次执行时，我们都用feed_dict参数，
  53.         # 将x_value绑定到x，将y_value绑定到y，
  54.         # 每次执行图形时我们都要计算损失、new_w1和new_w2；
  55.         # 这些张量的值以numpy数组的形式返回。
  56.         loss_value, _, _ = sess.run([loss, new_w1, new_w2], 
  57.                                     feed_dict={x: x_value, y: y_value})
  58.         print(loss_value)

nn模块

PyTorch：nn

计算图和autograd是十分强大的工具，可以定义复杂的操作并自动求导；然而对于大规模的网络，autograd太过于底层。

在构建神经网络时，我们经常考虑将计算安排成层，其中一些具有可学习的参数，它们将在学习过程中进行优化。

TensorFlow里，有类似Keras，TensorFlow-Slim和TFLearn这种封装了底层计算图的高度抽象的接口，这使得构建网络十分方便。

在PyTorch中，包nn完成了同样的功能。nn包中定义一组大致等价于层的模块。一个模块接受输入的tesnor，计算输出的tensor，而且还保存了一些内部状态比如需要学习的tensor的参数等。nn包中也定义了一组损失函数(loss functions），用来训练神经网络。

这个例子中，我们用nn包实现两层的网络：

  1. # 可运行代码见本文件夹中的 two_layer_net_nn.py
  2. import torch
  4. device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
  6. # N是批大小；D是输入维度
  7. # H是隐藏层维度；D_out是输出维度
  8. N, D_in, H, D_out = 64, 1000, 100, 10
  10. # 产生输入和输出随机张量
  11. x = torch.randn(N, D_in, device=device)
  12. y = torch.randn(N, D_out, device=device)
  15. # 使用nn包将我们的模型定义为一系列的层。
  16. # nn.Sequential是包含其他模块的模块，并按顺序应用这些模块来产生其输出。
  17. # 每个线性模块使用线性函数从输入计算输出，并保存其内部的权重和偏差张量。
  18. # 在构造模型之后，我们使用.to()方法将其移动到所需的设备。
  19. model = torch.nn.Sequential(
  20.             torch.nn.Linear(D_in, H),
  21.             torch.nn.ReLU(),
  22.             torch.nn.Linear(H, D_out),
  23.         ).to(device)
  26. # nn包还包含常用的损失函数的定义；
  27. # 在这种情况下，我们将使用平均平方误差(MSE)作为我们的损失函数。
  28. # 设置reduction='sum'，表示我们计算的是平方误差的“和”，而不是平均值;
  29. # 这是为了与前面我们手工计算损失的例子保持一致，
  30. # 但是在实践中，通过设置reduction='elementwise_mean'来使用均方误差作为损失更为常见。
  31. loss_fn = torch.nn.MSELoss(reduction='sum')
  33. learning_rate = 1e-4
  34. for t in range(500):
  36.     # 前向传播：通过向模型传入x计算预测的y。
  37.     # 模块对象重载了__call__运算符，所以可以像函数那样调用它们。
  38.     # 这么做相当于向模块传入了一个张量，然后它返回了一个输出张量。
  39.     y_pred = model(x)
  41.     # 计算并打印损失。我们传递包含y的预测值和真实值的张量，损失函数返回包含损失的张量。
  42.     loss = loss_fn(y_pred, y)
  43.     print(t, loss.item())
  45.     # 反向传播之前清零梯度
  46.     model.zero_grad()
  48.     # 反向传播：计算模型的损失对所有可学习参数的导数(梯度）。
  49.     # 在内部，每个模块的参数存储在requires_grad=True的张量中，
  50.     # 因此这个调用将计算模型中所有可学习参数的梯度。
  51.     loss.backward()
  53.     # 使用梯度下降更新权重。
  54.     # 每个参数都是张量，所以我们可以像我们以前那样可以得到它的数值和梯度
  55.     with torch.no_grad():
  56.         for param in model.parameters():
  57.             param.data -= learning_rate * param.grad

PyTorch：optim

到目前为止，我们已经通过手动改变包含可学习参数的张量来更新模型的权重。对于随机梯度下降(SGD/stochastic gradient descent)等简单的优化算法来说，这不是一个很大的负担，但在实践中，我们经常使用AdaGrad、RMSProp、Adam等更复杂的优化器来训练神经网络。

  1. # 可运行代码见本文件夹中的 two_layer_net_optim.py
  2. import torch
  4. # N是批大小；D是输入维度
  5. # H是隐藏层维度；D_out是输出维度
  6. N, D_in, H, D_out = 64, 1000, 100, 10
  8. # 产生随机输入和输出张量
  9. x = torch.randn(N, D_in)
  10. y = torch.randn(N, D_out)
  12. # 使用nn包定义模型和损失函数
  13. model = torch.nn.Sequential(
  14.           torch.nn.Linear(D_in, H),
  15.           torch.nn.ReLU(),
  16.           torch.nn.Linear(H, D_out),
  17.         )
  18. loss_fn = torch.nn.MSELoss(reduction='sum')
  20. # 使用optim包定义优化器(Optimizer）。Optimizer将会为我们更新模型的权重。
  21. # 这里我们使用Adam优化方法；optim包还包含了许多别的优化算法。
  22. # Adam构造函数的第一个参数告诉优化器应该更新哪些张量。
  23. learning_rate = 1e-4
  24. optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
  26. for t in range(500):
  28.     # 前向传播：通过像模型输入x计算预测的y
  29.     y_pred = model(x)
  31.     # 计算并打印loss
  32.     loss = loss_fn(y_pred, y)
  33.     print(t, loss.item())
  35.     # 在反向传播之前，使用optimizer将它要更新的所有张量的梯度清零(这些张量是模型可学习的权重)
  36.     optimizer.zero_grad()
  38.     # 反向传播：根据模型的参数计算loss的梯度
  39.     loss.backward()
  41.     # 调用Optimizer的step函数使它所有参数更新
  42.     optimizer.step()

PyTorch：自定义nn模块

有时候需要指定比现有模块序列更复杂的模型；对于这些情况，可以通过继承nn.Module并定义forward函数，这个forward函数可以使用其他模块或者其他的自动求导运算来接收输入tensor，产生输出tensor。

在这个例子中，我们用自定义Module的子类构建两层网络：

  1. # 可运行代码见本文件夹中的 two_layer_net_module.py
  2. import torch
  4. class TwoLayerNet(torch.nn.Module):
  5.     def __init__(self, D_in, H, D_out):
  6.         """
  7.         在构造函数中，我们实例化了两个nn.Linear模块，并将它们作为成员变量。
  8.         """
  9.         super(TwoLayerNet, self).__init__()
  10.         self.linear1 = torch.nn.Linear(D_in, H)
  11.         self.linear2 = torch.nn.Linear(H, D_out)
  13.     def forward(self, x):
  14.         """
  15.         在前向传播的函数中，我们接收一个输入的张量，也必须返回一个输出张量。
  16.         我们可以使用构造函数中定义的模块以及张量上的任意的(可微分的）操作。
  17.         """
  18.         h_relu = self.linear1(x).clamp(min=0)
  19.         y_pred = self.linear2(h_relu)
  20.         return y_pred
  22. # N是批大小； D_in 是输入维度；
  23. # H 是隐藏层维度； D_out 是输出维度
  24. N, D_in, H, D_out = 64, 1000, 100, 10
  26. # 产生输入和输出的随机张量
  27. x = torch.randn(N, D_in)
  28. y = torch.randn(N, D_out)
  30. # 通过实例化上面定义的类来构建我们的模型。
  31. model = TwoLayerNet(D_in, H, D_out)
  33. # 构造损失函数和优化器。
  34. # SGD构造函数中对model.parameters()的调用，
  35. # 将包含模型的一部分，即两个nn.Linear模块的可学习参数。
  36. loss_fn = torch.nn.MSELoss(reduction='sum')
  37. optimizer = torch.optim.SGD(model.parameters(), lr=1e-4)
  38. for t in range(500):
  39.     # 前向传播：通过向模型传递x计算预测值y
  40.     y_pred = model(x)
  42.     #计算并输出loss
  43.     loss = loss_fn(y_pred, y)
  44.     print(t, loss.item())
  46.     # 清零梯度，反向传播，更新权重
  47.     optimizer.zero_grad()
  48.     loss.backward()
  49.     optimizer.step()

PyTorch：控制流和权重共享

作为动态图和权重共享的一个例子，我们实现了一个非常奇怪的模型：一个全连接的ReLU网络，在每一次前向传播时，它的隐藏层的层数为随机1到4之间的数，这样可以多次重用相同的权重来计算。

因为这个模型可以使用普通的Python流控制来实现循环，并且我们可以通过在定义转发时多次重用同一个模块来实现最内层之间的权重共享。

我们利用Mudule的子类很容易实现这个模型：

  1. # 可运行代码见本文件夹中的 dynamic_net.py
  2. import random
  3. import torch
  5. class DynamicNet(torch.nn.Module):
  6.     def __init__(self, D_in, H, D_out):
  7.         """
  8.         在构造函数中，我们构造了三个nn.Linear实例，它们将在前向传播时被使用。
  9.         """
  10.         super(DynamicNet, self).__init__()
  11.         self.input_linear = torch.nn.Linear(D_in, H)
  12.         self.middle_linear = torch.nn.Linear(H, H)
  13.         self.output_linear = torch.nn.Linear(H, D_out)
  15.     def forward(self, x):
  16.         """
  17.         对于模型的前向传播，我们随机选择0、1、2、3，
  18.         并重用了多次计算隐藏层的middle_linear模块。
  19.         由于每个前向传播构建一个动态计算图，
  20.         我们可以在定义模型的前向传播时使用常规Python控制流运算符，如循环或条件语句。
  21.         在这里，我们还看到，在定义计算图形时多次重用同一个模块是完全安全的。
  22.         这是Lua Torch的一大改进，因为Lua Torch中每个模块只能使用一次。
  23.         """
  24.         h_relu = self.input_linear(x).clamp(min=0)
  25.         for _ in range(random.randint(0, 3)):
  26.             h_relu = self.middle_linear(h_relu).clamp(min=0)
  27.         y_pred = self.output_linear(h_relu)
  28.         return y_pred
  31. # N是批大小；D是输入维度
  32. # H是隐藏层维度；D_out是输出维度
  33. N, D_in, H, D_out = 64, 1000, 100, 10
  35. # 产生输入和输出随机张量
  36. x = torch.randn(N, D_in)
  37. y = torch.randn(N, D_out)
  39. # 实例化上面定义的类来构造我们的模型
  40. model = DynamicNet(D_in, H, D_out)
  42. # 构造我们的损失函数(loss function）和优化器(Optimizer）。
  43. # 用平凡的随机梯度下降训练这个奇怪的模型是困难的，所以我们使用了momentum方法。
  44. criterion = torch.nn.MSELoss(reduction='sum')
  45. optimizer = torch.optim.SGD(model.parameters(), lr=1e-4, momentum=0.9)
  46. for t in range(500):
  48.     # 前向传播：通过向模型传入x计算预测的y。
  49.     y_pred = model(x)
  51.     # 计算并打印损失
  52.     loss = criterion(y_pred, y)
  53.     print(t, loss.item())
  55.     # 清零梯度，反向传播，更新权重 
  56.     optimizer.zero_grad()
  57.     loss.backward()
  58.     optimizer.step()

Examples

You can browse the above examples here.

Tensors

https://pytorch.org/tutorials/_images/sphx_glr_two_layer_net_numpy_thumb.png

Warm-up: numpy

https://pytorch.org/tutorials/_images/sphx_glr_two_layer_net_tensor_thumb.png

PyTorch: Tensors

Autograd

https://pytorch.org/tutorials/_images/sphx_glr_two_layer_net_autograd_thumb.png

PyTorch: Tensors and autograd

https://pytorch.org/tutorials/_images/sphx_glr_two_layer_net_custom_function_thumb.png

PyTorch: Defining New autograd Functions

https://pytorch.org/tutorials/_images/sphx_glr_tf_two_layer_net_thumb.png

TensorFlow: Static Graphs

nn module

https://pytorch.org/tutorials/_images/sphx_glr_two_layer_net_nn_thumb.png

PyTorch: nn

https://pytorch.org/tutorials/_images/sphx_glr_two_layer_net_optim_thumb.png

PyTorch: optim

https://pytorch.org/tutorials/_images/sphx_glr_two_layer_net_module_thumb.png

PyTorch: Custom nn Modules

https://pytorch.org/tutorials/_images/sphx_glr_dynamic_net_thumb.png

PyTorch: Control Flow + Weight Sharing