PyTorch 通過示例學習 PyTorch

2020-09-10 14:47 更新
原文： https://pytorch.org/tutorials/beginner/pytorch_with_examples.html

作者：賈斯汀·約翰遜

本教程通過獨立的示例介紹 PyTorch 的基本概念。

PyTorch 的核心是提供兩個主要功能：

  • n 維張量，類似于 numpy，但可以在 GPU 上運行
  • 自動區(qū)分以構建和訓練神經網絡

我們將使用完全連接的 ReLU 網絡作為我們的運行示例。 該網絡將具有單個隱藏層，并且將通過最小化網絡輸出與真實輸出之間的歐幾里德距離來進行梯度下降訓練，以適應隨機數(shù)據(jù)。

張量

Warm-up：numpy

在介紹 PyTorch 之前，我們將首先使用 numpy 實現(xiàn)網絡。

Numpy 提供了一個 n 維數(shù)組對象，以及許多用于操縱這些數(shù)組的函數(shù)。 Numpy 是用于科學計算的通用框架。 它對計算圖，深度學習或梯度一無所知。 但是，我們可以使用 numpy 操作手動實現(xiàn)通過網絡的前向和后向傳遞，從而輕松地使用 numpy 使兩層網絡適合隨機數(shù)據(jù)：

  1. # -*- coding: utf-8 -*-
  2. import numpy as np
  5. ## N is batch size; D_in is input dimension;
  6. ## H is hidden dimension; D_out is output dimension.
  7. N, D_in, H, D_out = 64, 1000, 100, 10
  10. ## Create random input and output data
  11. x = np.random.randn(N, D_in)
  12. y = np.random.randn(N, D_out)
  15. ## Randomly initialize weights
  16. w1 = np.random.randn(D_in, H)
  17. w2 = np.random.randn(H, D_out)
  20. learning_rate = 1e-6
  21. for t in range(500):
  22.     # Forward pass: compute predicted y
  23.     h = x.dot(w1)
  24.     h_relu = np.maximum(h, 0)
  25.     y_pred = h_relu.dot(w2)
  28.     # Compute and print loss
  29.     loss = np.square(y_pred - y).sum()
  30.     print(t, loss)
  33.     # Backprop to compute gradients of w1 and w2 with respect to loss
  34.     grad_y_pred = 2.0 * (y_pred - y)
  35.     grad_w2 = h_relu.T.dot(grad_y_pred)
  36.     grad_h_relu = grad_y_pred.dot(w2.T)
  37.     grad_h = grad_h_relu.copy()
  38.     grad_h[h < 0] = 0
  39.     grad_w1 = x.T.dot(grad_h)
  42.     # Update weights
  43.     w1 -= learning_rate * grad_w1
  44.     w2 -= learning_rate * grad_w2

PyTorch：張量

Numpy 是一個很棒的框架，但是它不能利用 GPU 來加速其數(shù)值計算。 對于現(xiàn)代深度神經網絡，GPU 通常會提供 50 倍或更高的加速，因此遺憾的是，numpy 不足以實現(xiàn)現(xiàn)代深度學習。

在這里，我們介紹最基本的 PyTorch 概念：張量。 PyTorch 張量在概念上與 numpy 數(shù)組相同：張量是 n 維數(shù)組，而 PyTorch 提供了許多在這些張量上運行的功能。 在幕后，張量可以跟蹤計算圖和漸變，但它們也可用作科學計算的通用工具。

與 numpy 不同，PyTorch 張量可以利用 GPU 加速其數(shù)字計算。 要在 GPU 上運行 PyTorch Tensor，只需要將其轉換為新的數(shù)據(jù)類型。

在這里，我們使用 PyTorch 張量使兩層網絡適合隨機數(shù)據(jù)。 像上面的 numpy 示例一樣，我們需要手動實現(xiàn)通過網絡的正向和反向傳遞：

  1. # -*- coding: utf-8 -*-
  4. import torch
  7. dtype = torch.float
  8. device = torch.device("cpu")
  9. ## device = torch.device("cuda:0") # Uncomment this to run on GPU
  12. ## N is batch size; D_in is input dimension;
  13. ## H is hidden dimension; D_out is output dimension.
  14. N, D_in, H, D_out = 64, 1000, 100, 10
  17. ## Create random input and output data
  18. x = torch.randn(N, D_in, device=device, dtype=dtype)
  19. y = torch.randn(N, D_out, device=device, dtype=dtype)
  22. ## Randomly initialize weights
  23. w1 = torch.randn(D_in, H, device=device, dtype=dtype)
  24. w2 = torch.randn(H, D_out, device=device, dtype=dtype)
  27. learning_rate = 1e-6
  28. for t in range(500):
  29.     # Forward pass: compute predicted y
  30.     h = x.mm(w1)
  31.     h_relu = h.clamp(min=0)
  32.     y_pred = h_relu.mm(w2)
  35.     # Compute and print loss
  36.     loss = (y_pred - y).pow(2).sum().item()
  37.     if t % 100 == 99:
  38.         print(t, loss)
  41.     # Backprop to compute gradients of w1 and w2 with respect to loss
  42.     grad_y_pred = 2.0 * (y_pred - y)
  43.     grad_w2 = h_relu.t().mm(grad_y_pred)
  44.     grad_h_relu = grad_y_pred.mm(w2.t())
  45.     grad_h = grad_h_relu.clone()
  46.     grad_h[h < 0] = 0
  47.     grad_w1 = x.t().mm(grad_h)
  50.     # Update weights using gradient descent
  51.     w1 -= learning_rate * grad_w1
  52.     w2 -= learning_rate * grad_w2

自動分級

PyTorch：張量和自定等級

在以上示例中，我們必須手動實現(xiàn)神經網絡的正向和反向傳遞。 對于小型的兩層網絡，手動實施反向傳遞并不是什么大問題，但是對于大型的復雜網絡而言，可以很快變得非常麻煩。

幸運的是，我們可以使用自動微分來自動計算神經網絡中的反向傳遞。 PyTorch 中的 autograd 軟件包正是提供了此功能。 使用 autograd 時，網絡的正向傳遞將定義計算圖； 圖中的節(jié)點為張量，邊為從輸入張量生成輸出張量的函數(shù)。 然后通過該圖進行反向傳播，可以輕松計算梯度。

這聽起來很復雜，在實踐中非常簡單。 每個張量代表計算圖中的一個節(jié)點。 如果x是具有x.requires_grad=True的張量，則x.grad是另一個張量，其保持x相對于某個標量值的梯度。

在這里，我們使用 PyTorch 張量和 autograd 來實現(xiàn)我們的兩層網絡。 現(xiàn)在我們不再需要手動通過網絡實現(xiàn)反向傳遞：

  1. # -*- coding: utf-8 -*-
  2. import torch
  5. dtype = torch.float
  6. device = torch.device("cpu")
  7. ## device = torch.device("cuda:0") # Uncomment this to run on GPU
  10. ## N is batch size; D_in is input dimension;
  11. ## H is hidden dimension; D_out is output dimension.
  12. N, D_in, H, D_out = 64, 1000, 100, 10
  15. ## Create random Tensors to hold input and outputs.
  16. ## Setting requires_grad=False indicates that we do not need to compute gradients
  17. ## with respect to these Tensors during the backward pass.
  18. x = torch.randn(N, D_in, device=device, dtype=dtype)
  19. y = torch.randn(N, D_out, device=device, dtype=dtype)
  22. ## Create random Tensors for weights.
  23. ## Setting requires_grad=True indicates that we want to compute gradients with
  24. ## respect to these Tensors during the backward pass.
  25. w1 = torch.randn(D_in, H, device=device, dtype=dtype, requires_grad=True)
  26. w2 = torch.randn(H, D_out, device=device, dtype=dtype, requires_grad=True)
  29. learning_rate = 1e-6
  30. for t in range(500):
  31.     # Forward pass: compute predicted y using operations on Tensors; these
  32.     # are exactly the same operations we used to compute the forward pass using
  33.     # Tensors, but we do not need to keep references to intermediate values since
  34.     # we are not implementing the backward pass by hand.
  35.     y_pred = x.mm(w1).clamp(min=0).mm(w2)
  38.     # Compute and print loss using operations on Tensors.
  39.     # Now loss is a Tensor of shape (1,)
  40.     # loss.item() gets the scalar value held in the loss.
  41.     loss = (y_pred - y).pow(2).sum()
  42.     if t % 100 == 99:
  43.         print(t, loss.item())
  46.     # Use autograd to compute the backward pass. This call will compute the
  47.     # gradient of loss with respect to all Tensors with requires_grad=True.
  48.     # After this call w1.grad and w2.grad will be Tensors holding the gradient
  49.     # of the loss with respect to w1 and w2 respectively.
  50.     loss.backward()
  53.     # Manually update weights using gradient descent. Wrap in torch.no_grad()
  54.     # because weights have requires_grad=True, but we don't need to track this
  55.     # in autograd.
  56.     # An alternative way is to operate on weight.data and weight.grad.data.
  57.     # Recall that tensor.data gives a tensor that shares the storage with
  58.     # tensor, but doesn't track history.
  59.     # You can also use torch.optim.SGD to achieve this.
  60.     with torch.no_grad():
  61.         w1 -= learning_rate * w1.grad
  62.         w2 -= learning_rate * w2.grad
  65.         # Manually zero the gradients after updating weights
  66.         w1.grad.zero_()
  67.         w2.grad.zero_()

PyTorch：定義新的autograd功能

在幕后，每個原始的 autograd 運算符實際上都是在 Tensor 上運行的兩個函數(shù)。 正向函數(shù)從輸入張量計算輸出張量。 向后函數(shù)接收相對于某個標量值的輸出張量的梯度，并計算相對于相同標量值的輸入張量的梯度。

在 PyTorch 中，我們可以通過定義torch.autograd.Function的子類并實現(xiàn)forward和backward函數(shù)來輕松定義自己的 autograd 運算符。 然后，我們可以通過構造實例并像調用函數(shù)一樣調用新的 autograd 運算符，并傳遞包含輸入數(shù)據(jù)的張量。

在此示例中，我們定義了自己的自定義 autograd 函數(shù)來執(zhí)行 ReLU 非線性，并使用它來實現(xiàn)我們的兩層網絡：

  1. # -*- coding: utf-8 -*-
  2. import torch
  5. class MyReLU(torch.autograd.Function):
  6.     """
  7.     We can implement our own custom autograd Functions by subclassing
  8.     torch.autograd.Function and implementing the forward and backward passes
  9.     which operate on Tensors.
  10.     """
  13.     @staticmethod
  14.     def forward(ctx, input):
  15.         """
  16.         In the forward pass we receive a Tensor containing the input and return
  17.         a Tensor containing the output. ctx is a context object that can be used
  18.         to stash information for backward computation. You can cache arbitrary
  19.         objects for use in the backward pass using the ctx.save_for_backward method.
  20.         """
  21.         ctx.save_for_backward(input)
  22.         return input.clamp(min=0)
  25.     @staticmethod
  26.     def backward(ctx, grad_output):
  27.         """
  28.         In the backward pass we receive a Tensor containing the gradient of the loss
  29.         with respect to the output, and we need to compute the gradient of the loss
  30.         with respect to the input.
  31.         """
  32.         input, = ctx.saved_tensors
  33.         grad_input = grad_output.clone()
  34.         grad_input[input < 0] = 0
  35.         return grad_input
  38. dtype = torch.float
  39. device = torch.device("cpu")
  40. ## device = torch.device("cuda:0") # Uncomment this to run on GPU
  43. ## N is batch size; D_in is input dimension;
  44. ## H is hidden dimension; D_out is output dimension.
  45. N, D_in, H, D_out = 64, 1000, 100, 10
  48. ## Create random Tensors to hold input and outputs.
  49. x = torch.randn(N, D_in, device=device, dtype=dtype)
  50. y = torch.randn(N, D_out, device=device, dtype=dtype)
  53. ## Create random Tensors for weights.
  54. w1 = torch.randn(D_in, H, device=device, dtype=dtype, requires_grad=True)
  55. w2 = torch.randn(H, D_out, device=device, dtype=dtype, requires_grad=True)
  58. learning_rate = 1e-6
  59. for t in range(500):
  60.     # To apply our Function, we use Function.apply method. We alias this as 'relu'.
  61.     relu = MyReLU.apply
  64.     # Forward pass: compute predicted y using operations; we compute
  65.     # ReLU using our custom autograd operation.
  66.     y_pred = relu(x.mm(w1)).mm(w2)
  69.     # Compute and print loss
  70.     loss = (y_pred - y).pow(2).sum()
  71.     if t % 100 == 99:
  72.         print(t, loss.item())
  75.     # Use autograd to compute the backward pass.
  76.     loss.backward()
  79.     # Update weights using gradient descent
  80.     with torch.no_grad():
  81.         w1 -= learning_rate * w1.grad
  82.         w2 -= learning_rate * w2.grad
  85.         # Manually zero the gradients after updating weights
  86.         w1.grad.zero_()
  87.         w2.grad.zero_()

<cite>nn</cite>模塊

PyTorch：nn

計算圖和 autograd 是定義復雜運算符并自動采用導數(shù)的非常強大的范例。 但是對于大型神經網絡，原始的 autograd 可能會有點太低了。

在構建神經網絡時，我們經常想到將計算安排在層中，其中某些層具有可學習的參數(shù)，這些參數(shù)將在學習期間進行優(yōu)化。

在 TensorFlow 中，像 Keras ， TensorFlow-Slim 和 TFLearn 之類的軟件包在原始計算圖上提供了更高層次的抽象，可用于構建神經網絡。

在 PyTorch 中，nn包也達到了相同的目的。 nn包定義了一組模塊，它們大致等效于神經網絡層。 模塊接收輸入張量并計算輸出張量，但也可以保持內部狀態(tài)，例如包含可學習參數(shù)的張量。 nn程序包還定義了一組有用的損失函數(shù)，這些函數(shù)通常在訓練神經網絡時使用。

在此示例中，我們使用nn包來實現(xiàn)我們的兩層網絡：

  1. # -*- coding: utf-8 -*-
  2. import torch
  5. ## N is batch size; D_in is input dimension;
  6. ## H is hidden dimension; D_out is output dimension.
  7. N, D_in, H, D_out = 64, 1000, 100, 10
  10. ## Create random Tensors to hold inputs and outputs
  11. x = torch.randn(N, D_in)
  12. y = torch.randn(N, D_out)
  15. ## Use the nn package to define our model as a sequence of layers. nn.Sequential
  16. ## is a Module which contains other Modules, and applies them in sequence to
  17. ## produce its output. Each Linear Module computes output from input using a
  18. ## linear function, and holds internal Tensors for its weight and bias.
  19. model = torch.nn.Sequential(
  20.     torch.nn.Linear(D_in, H),
  21.     torch.nn.ReLU(),
  22.     torch.nn.Linear(H, D_out),
  23. )
  26. ## The nn package also contains definitions of popular loss functions; in this
  27. ## case we will use Mean Squared Error (MSE) as our loss function.
  28. loss_fn = torch.nn.MSELoss(reduction='sum')
  31. learning_rate = 1e-4
  32. for t in range(500):
  33.     # Forward pass: compute predicted y by passing x to the model. Module objects
  34.     # override the __call__ operator so you can call them like functions. When
  35.     # doing so you pass a Tensor of input data to the Module and it produces
  36.     # a Tensor of output data.
  37.     y_pred = model(x)
  40.     # Compute and print loss. We pass Tensors containing the predicted and true
  41.     # values of y, and the loss function returns a Tensor containing the
  42.     # loss.
  43.     loss = loss_fn(y_pred, y)
  44.     if t % 100 == 99:
  45.         print(t, loss.item())
  48.     # Zero the gradients before running the backward pass.
  49.     model.zero_grad()
  52.     # Backward pass: compute gradient of the loss with respect to all the learnable
  53.     # parameters of the model. Internally, the parameters of each Module are stored
  54.     # in Tensors with requires_grad=True, so this call will compute gradients for
  55.     # all learnable parameters in the model.
  56.     loss.backward()
  59.     # Update the weights using gradient descent. Each parameter is a Tensor, so
  60.     # we can access its gradients like we did before.
  61.     with torch.no_grad():
  62.         for param in model.parameters():
  63.             param -= learning_rate * param.grad

PyTorch：優(yōu)化

到目前為止，我們通過手動更改持有可學習參數(shù)的張量(使用torch.no_grad()或.data來避免在自動分級中跟蹤歷史記錄）來更新模型的權重。 對于像隨機梯度下降這樣的簡單優(yōu)化算法而言，這并不是一個巨大的負擔，但是在實踐中，我們經常使用更復雜的優(yōu)化器(例如 AdaGrad，RMSProp，Adam 等）來訓練神經網絡。

PyTorch 中的optim軟件包抽象了優(yōu)化算法的思想，并提供了常用優(yōu)化算法的實現(xiàn)。

在此示例中，我們將使用nn包像以前一樣定義我們的模型，但是我們將使用optim包提供的 Adam 算法優(yōu)化模型：

  1. # -*- coding: utf-8 -*-
  2. import torch
  5. ## N is batch size; D_in is input dimension;
  6. ## H is hidden dimension; D_out is output dimension.
  7. N, D_in, H, D_out = 64, 1000, 100, 10
  10. ## Create random Tensors to hold inputs and outputs
  11. x = torch.randn(N, D_in)
  12. y = torch.randn(N, D_out)
  15. ## Use the nn package to define our model and loss function.
  16. model = torch.nn.Sequential(
  17.     torch.nn.Linear(D_in, H),
  18.     torch.nn.ReLU(),
  19.     torch.nn.Linear(H, D_out),
  20. )
  21. loss_fn = torch.nn.MSELoss(reduction='sum')
  24. ## Use the optim package to define an Optimizer that will update the weights of
  25. ## the model for us. Here we will use Adam; the optim package contains many other
  26. ## optimization algoriths. The first argument to the Adam constructor tells the
  27. ## optimizer which Tensors it should update.
  28. learning_rate = 1e-4
  29. optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
  30. for t in range(500):
  31.     # Forward pass: compute predicted y by passing x to the model.
  32.     y_pred = model(x)
  35.     # Compute and print loss.
  36.     loss = loss_fn(y_pred, y)
  37.     if t % 100 == 99:
  38.         print(t, loss.item())
  41.     # Before the backward pass, use the optimizer object to zero all of the
  42.     # gradients for the variables it will update (which are the learnable
  43.     # weights of the model). This is because by default, gradients are
  44.     # accumulated in buffers( i.e, not overwritten) whenever .backward()
  45.     # is called. Checkout docs of torch.autograd.backward for more details.
  46.     optimizer.zero_grad()
  49.     # Backward pass: compute gradient of the loss with respect to model
  50.     # parameters
  51.     loss.backward()
  54.     # Calling the step function on an Optimizer makes an update to its
  55.     # parameters
  56.     optimizer.step()

PyTorch：自定義 nn 模塊

有時，您將需要指定比一系列現(xiàn)有模塊更復雜的模型。 對于這些情況，您可以通過子類化nn.Module并定義一個forward來定義自己的模塊，該模塊使用其他模塊或在 Tensors 上的其他自動轉換操作來接收輸入 Tensors 并生成輸出 Tensors。

在此示例中，我們將兩層網絡實現(xiàn)為自定義的 Module 子類：

  1. # -*- coding: utf-8 -*-
  2. import torch
  5. class TwoLayerNet(torch.nn.Module):
  6.     def __init__(self, D_in, H, D_out):
  7.         """
  8.         In the constructor we instantiate two nn.Linear modules and assign them as
  9.         member variables.
  10.         """
  11.         super(TwoLayerNet, self).__init__()
  12.         self.linear1 = torch.nn.Linear(D_in, H)
  13.         self.linear2 = torch.nn.Linear(H, D_out)
  16.     def forward(self, x):
  17.         """
  18.         In the forward function we accept a Tensor of input data and we must return
  19.         a Tensor of output data. We can use Modules defined in the constructor as
  20.         well as arbitrary operators on Tensors.
  21.         """
  22.         h_relu = self.linear1(x).clamp(min=0)
  23.         y_pred = self.linear2(h_relu)
  24.         return y_pred
  27. ## N is batch size; D_in is input dimension;
  28. ## H is hidden dimension; D_out is output dimension.
  29. N, D_in, H, D_out = 64, 1000, 100, 10
  32. ## Create random Tensors to hold inputs and outputs
  33. x = torch.randn(N, D_in)
  34. y = torch.randn(N, D_out)
  37. ## Construct our model by instantiating the class defined above
  38. model = TwoLayerNet(D_in, H, D_out)
  41. ## Construct our loss function and an Optimizer. The call to model.parameters()
  42. ## in the SGD constructor will contain the learnable parameters of the two
  43. ## nn.Linear modules which are members of the model.
  44. criterion = torch.nn.MSELoss(reduction='sum')
  45. optimizer = torch.optim.SGD(model.parameters(), lr=1e-4)
  46. for t in range(500):
  47.     # Forward pass: Compute predicted y by passing x to the model
  48.     y_pred = model(x)
  51.     # Compute and print loss
  52.     loss = criterion(y_pred, y)
  53.     if t % 100 == 99:
  54.         print(t, loss.item())
  57.     # Zero gradients, perform a backward pass, and update the weights.
  58.     optimizer.zero_grad()
  59.     loss.backward()
  60.     optimizer.step()

PyTorch：控制流+權重共享

作為動態(tài)圖和權重共享的示例，我們實現(xiàn)了一個非常奇怪的模型：一個完全連接的 ReLU 網絡，該網絡在每個前向傳遞中選擇 1 到 4 之間的隨機數(shù)，并使用那么多隱藏層，多次重復使用相同的權重 計算最里面的隱藏層。

對于此模型，我們可以使用常規(guī)的 Python 流控制來實現(xiàn)循環(huán)，并且可以通過在定義前向傳遞時簡單地多次重復使用同一模塊來實現(xiàn)最內層之間的權重共享。

我們可以輕松地將此模型實現(xiàn)為 Module 子類：

  1. # -*- coding: utf-8 -*-
  2. import random
  3. import torch
  6. class DynamicNet(torch.nn.Module):
  7.     def __init__(self, D_in, H, D_out):
  8.         """
  9.         In the constructor we construct three nn.Linear instances that we will use
  10.         in the forward pass.
  11.         """
  12.         super(DynamicNet, self).__init__()
  13.         self.input_linear = torch.nn.Linear(D_in, H)
  14.         self.middle_linear = torch.nn.Linear(H, H)
  15.         self.output_linear = torch.nn.Linear(H, D_out)
  18.     def forward(self, x):
  19.         """
  20.         For the forward pass of the model, we randomly choose either 0, 1, 2, or 3
  21.         and reuse the middle_linear Module that many times to compute hidden layer
  22.         representations.
  25.         Since each forward pass builds a dynamic computation graph, we can use normal
  26.         Python control-flow operators like loops or conditional statements when
  27.         defining the forward pass of the model.
  30.         Here we also see that it is perfectly safe to reuse the same Module many
  31.         times when defining a computational graph. This is a big improvement from Lua
  32.         Torch, where each Module could be used only once.
  33.         """
  34.         h_relu = self.input_linear(x).clamp(min=0)
  35.         for _ in range(random.randint(0, 3)):
  36.             h_relu = self.middle_linear(h_relu).clamp(min=0)
  37.         y_pred = self.output_linear(h_relu)
  38.         return y_pred
  41. ## N is batch size; D_in is input dimension;
  42. ## H is hidden dimension; D_out is output dimension.
  43. N, D_in, H, D_out = 64, 1000, 100, 10
  46. ## Create random Tensors to hold inputs and outputs
  47. x = torch.randn(N, D_in)
  48. y = torch.randn(N, D_out)
  51. ## Construct our model by instantiating the class defined above
  52. model = DynamicNet(D_in, H, D_out)
  55. ## Construct our loss function and an Optimizer. Training this strange model with
  56. ## vanilla stochastic gradient descent is tough, so we use momentum
  57. criterion = torch.nn.MSELoss(reduction='sum')
  58. optimizer = torch.optim.SGD(model.parameters(), lr=1e-4, momentum=0.9)
  59. for t in range(500):
  60.     # Forward pass: Compute predicted y by passing x to the model
  61.     y_pred = model(x)
  64.     # Compute and print loss
  65.     loss = criterion(y_pred, y)
  66.     if t % 100 == 99:
  67.         print(t, loss.item())
  70.     # Zero gradients, perform a backward pass, and update the weights.
  71.     optimizer.zero_grad()
  72.     loss.backward()
  73.     optimizer.step()

范例

您可以在此處瀏覽以上示例。

張量

../_images/sphx_glr_two_layer_net_numpy_thumb.png

Warm-up：numpy

../_images/sphx_glr_two_layer_net_tensor_thumb.png

PyTorch：張量

自動分級

../_images/sphx_glr_two_layer_net_autograd_thumb.png

PyTorch：張量和自定等級

../_images/sphx_glr_two_layer_net_custom_function_thumb.png

PyTorch：定義新的autograd函數(shù)

../_images/sphx_glr_tf_two_layer_net_thumb.png

TensorFlow：靜態(tài)圖

<cite>nn</cite>模塊

../_images/sphx_glr_two_layer_net_nn_thumb.png

PyTorch：nn

../_images/sphx_glr_two_layer_net_optim_thumb.png

PyTorch：優(yōu)化

../_images/sphx_glr_two_layer_net_module_thumb.png

PyTorch：自定義nn模塊

../_images/sphx_glr_dynamic_net_thumb.png

PyTorch：控制流+權重共享


以上內容是否對您有幫助：
在線筆記
App下載
App下載

掃描二維碼

下載編程獅App

公眾號
微信公眾號

編程獅公眾號