注意
单击 这里 下载完整示例代码
什么是 torch.nn 真的？¶
作者：Jeremy Howard，fast.ai。感谢 Rachel Thomas 和 Francisco Ingham。
我们建议将本教程作为笔记本运行，而不是脚本。要下载笔记本 (.ipynb) 文件，请单击页面顶部的链接。
PyTorch 提供了精心设计的模块和类，例如 torch.nn、torch.optim、Dataset 和 DataLoader，帮助您创建和训练神经网络。为了充分利用它们的强大功能并根据您的问题进行自定义，您需要真正了解它们的工作原理。为了培养这种理解，我们将首先在 MNIST 数据集上训练一个基本的神经网络，不使用这些模型中的任何功能；我们最初只使用最基本的 PyTorch 张量功能。然后，我们将一次添加一个来自 torch.nn、torch.optim、Dataset 或 DataLoader 的功能，展示每个部分的作用，以及它如何使代码更简洁或更灵活。
本教程假定您已经安装了 PyTorch，并且熟悉张量操作的基础知识。（如果您熟悉 Numpy 数组操作，您会发现这里使用的 PyTorch 张量操作几乎相同）。
MNIST 数据集设置¶
我们将使用经典的 MNIST 数据集，它包含手写数字（0 到 9 之间）的黑白图像。
我们将使用 pathlib 处理路径（Python 3 标准库的一部分），并将使用 requests 下载数据集。我们只会在使用模块时才导入它们，因此您可以确切地了解每个步骤中使用了什么。
from pathlib import Path
import requests
DATA_PATH = Path("data")
PATH = DATA_PATH / "mnist"
PATH.mkdir(parents=True, exist_ok=True)
URL = "https://github.com/pytorch/tutorials/raw/main/_static/"
FILENAME = "mnist.pkl.gz"
if not (PATH / FILENAME).exists():
content = requests.get(URL + FILENAME).content
(PATH / FILENAME).open("wb").write(content)
此数据集采用 numpy 数组格式，并使用 pickle（一种特定于 Python 的数据序列化格式）存储。
每张图像都是 28 x 28 的，并被存储为长度为 784 (=28x28) 的扁平化行。让我们看一看其中一张；我们需要先将其重新整形为二维。
from matplotlib import pyplot
import numpy as np
pyplot.imshow(x_train[0].reshape((28, 28)), cmap="gray")
# ``pyplot.show()`` only if not on Colab
try:
import google.colab
except ImportError:
pyplot.show()
print(x_train.shape)
(50000, 784)
PyTorch 使用 torch.tensor 而不是 numpy 数组，因此我们需要将数据进行转换。
import torch
x_train, y_train, x_valid, y_valid = map(
torch.tensor, (x_train, y_train, x_valid, y_valid)
)
n, c = x_train.shape
print(x_train, y_train)
print(x_train.shape)
print(y_train.min(), y_train.max())
tensor([[0., 0., 0., ..., 0., 0., 0.],
[0., 0., 0., ..., 0., 0., 0.],
[0., 0., 0., ..., 0., 0., 0.],
...,
[0., 0., 0., ..., 0., 0., 0.],
[0., 0., 0., ..., 0., 0., 0.],
[0., 0., 0., ..., 0., 0., 0.]]) tensor([5, 0, 4, ..., 8, 4, 8])
torch.Size([50000, 784])
tensor(0) tensor(9)
从头开始构建神经网络（不使用 torch.nn）¶
让我们首先使用 PyTorch 张量操作创建一个模型。我们假设您已经熟悉神经网络的基础知识。（如果您不熟悉，可以在 course.fast.ai 学习）。
PyTorch 提供了创建随机或零填充张量的方法，我们将使用这些方法为一个简单的线性模型创建权重和偏差。这些只是普通的张量，只有一个非常特殊的添加：我们告诉 PyTorch 它们需要梯度。这使得 PyTorch 记录对张量执行的所有操作，以便它可以自动计算反向传播期间的梯度！
对于权重，我们在初始化之后设置 requires_grad，因为我们不希望该步骤包含在梯度中。（注意，PyTorch 中的尾随 _ 表示操作是在原地执行的）。
注意
我们在这里使用 Xavier 初始化 初始化权重（通过乘以 1/sqrt(n)）。
import math
weights = torch.randn(784, 10) / math.sqrt(784)
weights.requires_grad_()
bias = torch.zeros(10, requires_grad=True)
由于 PyTorch 能够自动计算梯度，我们可以使用任何标准的 Python 函数（或可调用对象）作为模型！因此，让我们只编写一个简单的矩阵乘法和广播加法来创建一个简单的线性模型。我们还需要一个激活函数，所以我们将编写 log_softmax 并使用它。请记住：虽然 PyTorch 提供了大量的预先编写的损失函数、激活函数等，但您可以轻松地使用纯 Python 编写自己的函数。PyTorch 甚至会自动为您创建快速的 GPU 或矢量化的 CPU 代码。
在上面，@ 代表矩阵乘法运算。我们将对一批数据（在本例中为 64 张图像）调用我们的函数。这是一个前向传播。请注意，由于我们从随机权重开始，因此我们的预测不会比随机更好。
bs = 64 # batch size
xb = x_train[0:bs] # a mini-batch from x
preds = model(xb) # predictions
preds[0], preds.shape
print(preds[0], preds.shape)
tensor([-2.5452, -2.0790, -2.1832, -2.6221, -2.3670, -2.3854, -2.9432, -2.4391,
-1.8657, -2.0355], grad_fn=<SelectBackward0>) torch.Size([64, 10])
正如您所看到的，preds 张量不仅包含张量值，还包含梯度函数。我们稍后将使用它来进行反向传播。
让我们实现负对数似然，作为损失函数（同样，我们也可以使用标准 Python）
def nll(input, target):
return -input[range(target.shape[0]), target].mean()
loss_func = nll
让我们使用我们的随机模型检查一下我们的损失，这样我们就可以看看在反向传播之后损失是否有所改善。
tensor(2.4020, grad_fn=<NegBackward0>)
让我们也实现一个函数来计算模型的准确率。对于每个预测，如果具有最大值的索引与目标值匹配，那么预测是正确的。
def accuracy(out, yb):
preds = torch.argmax(out, dim=1)
return (preds == yb).float().mean()
让我们检查一下我们的随机模型的准确率，这样我们就可以看看随着损失的改善，我们的准确率是否也会有所提高。
tensor(0.0938)
现在我们可以运行一个训练循环。对于每个迭代，我们将
选择一批数据（大小为
bs）使用模型进行预测
计算损失
loss.backward()更新模型的梯度，在本例中为weights和bias。
现在，我们使用这些梯度来更新权重和偏差。我们将在 torch.no_grad() 上下文管理器中执行此操作，因为我们不希望这些操作被记录到我们下一次计算梯度的过程中。您可以阅读更多关于 PyTorch 的 Autograd 如何记录操作的信息 here。
然后我们将梯度设置为零，这样我们就准备好进行下一个循环。否则，我们的梯度将记录所有已发生操作的运行总计（即 loss.backward()添加梯度到已存储的任何内容，而不是替换它们）。
小贴士
您可以使用标准 Python 调试器逐步执行 PyTorch 代码，使您能够在每个步骤检查各种变量值。取消下面的 set_trace() 注释以试用。
from IPython.core.debugger import set_trace
lr = 0.5 # learning rate
epochs = 2 # how many epochs to train for
for epoch in range(epochs):
for i in range((n - 1) // bs + 1):
# set_trace()
start_i = i * bs
end_i = start_i + bs
xb = x_train[start_i:end_i]
yb = y_train[start_i:end_i]
pred = model(xb)
loss = loss_func(pred, yb)
loss.backward()
with torch.no_grad():
weights -= weights.grad * lr
bias -= bias.grad * lr
weights.grad.zero_()
bias.grad.zero_()
就是这样：我们已经从头开始创建并训练了一个最小的神经网络（在本例中，是一个逻辑回归，因为我们没有隐藏层）！
让我们检查损失和准确率，并将它们与我们之前得到的进行比较。我们预计损失会降低，准确率会提高，而且确实如此。
tensor(0.0813, grad_fn=<NegBackward0>) tensor(1.)
使用 torch.nn.functional¶
现在我们将重构我们的代码，使其与之前做的事情相同，只是我们将开始利用 PyTorch 的 nn 类来使代码更简洁和更灵活。从这里开始的每个步骤，我们应该使代码更简洁、更易理解和/或更灵活。
第一步也是最简单的一步是使用 torch.nn.functional 替换我们手写的激活和损失函数，从而使代码更简洁（通常按惯例将其导入命名空间 F）。此模块包含 torch.nn 库中的所有函数（而库的其他部分包含类）。除了各种损失和激活函数外，您还可以在此找到一些用于创建神经网络的便捷函数，例如池化函数。（还有用于执行卷积、线性层等的函数，但正如我们将在下面看到的那样，这些通常最好使用库的其他部分来处理）。
如果您使用的是负对数似然损失和 log softmax 激活，那么 Pytorch 提供了一个单独的函数 F.cross_entropy 来组合这两个函数。因此，我们甚至可以从模型中删除激活函数。
import torch.nn.functional as F
loss_func = F.cross_entropy
def model(xb):
return xb @ weights + bias
请注意，我们不再在 model 函数中调用 log_softmax。让我们确认一下我们的损失和准确率与之前相同
tensor(0.0813, grad_fn=<NllLossBackward0>) tensor(1.)
使用 nn.Module 重构¶
接下来，我们将使用 nn.Module 和 nn.Parameter，以获得更清晰和更简洁的训练循环。我们对 nn.Module（它本身就是一个类，能够跟踪状态）进行子类化。在本例中，我们希望创建一个包含权重、偏差和前向步骤方法的类。 nn.Module 具有许多属性和方法（例如 .parameters() 和 .zero_grad()），我们将使用这些属性和方法。
注意
nn.Module（大写 M）是一个 PyTorch 特定的概念，它是一个我们将经常使用的类。 nn.Module 不要与 Python 中的（小写 m）module 概念混淆，后者是一个可以导入的 Python 代码文件。
from torch import nn
class Mnist_Logistic(nn.Module):
def __init__(self):
super().__init__()
self.weights = nn.Parameter(torch.randn(784, 10) / math.sqrt(784))
self.bias = nn.Parameter(torch.zeros(10))
def forward(self, xb):
return xb @ self.weights + self.bias
由于我们现在使用的是对象而不是仅仅使用函数，因此我们首先必须实例化我们的模型
model = Mnist_Logistic()
现在我们可以像以前一样计算损失。请注意，nn.Module 对象的使用方式与函数相同（即它们是可调用的），但在幕后，Pytorch 将自动调用我们的 forward 方法。
tensor(2.3096, grad_fn=<NllLossBackward0>)
之前，对于我们的训练循环，我们必须通过名称更新每个参数的值，并手动为每个参数单独清零梯度，如下所示
with torch.no_grad():
weights -= weights.grad * lr
bias -= bias.grad * lr
weights.grad.zero_()
bias.grad.zero_()
现在，我们可以利用 model.parameters() 和 model.zero_grad()（这两个方法都是 PyTorch 为 nn.Module 定义的）来使这些步骤更简洁，并且不太容易出现忘记某些参数的错误，尤其是在我们的模型更加复杂的情况下
with torch.no_grad():
for p in model.parameters(): p -= p.grad * lr
model.zero_grad()
我们将把我们的训练循环包装在一个 fit 函数中，这样我们就可以稍后再运行它。
def fit():
for epoch in range(epochs):
for i in range((n - 1) // bs + 1):
start_i = i * bs
end_i = start_i + bs
xb = x_train[start_i:end_i]
yb = y_train[start_i:end_i]
pred = model(xb)
loss = loss_func(pred, yb)
loss.backward()
with torch.no_grad():
for p in model.parameters():
p -= p.grad * lr
model.zero_grad()
fit()
让我们仔细检查一下我们的损失是否下降
tensor(0.0821, grad_fn=<NllLossBackward0>)
使用 nn.Linear 重构¶
我们将继续重构代码。与其手动定义和初始化 self.weights 和 self.bias，并计算 xb @ self.weights + self.bias，我们将使用 Pytorch 类 nn.Linear 来创建线性层，该类会为我们执行所有这些操作。Pytorch 有许多类型的预定义层，可以大大简化我们的代码，通常还可以使其更快。
我们像以前一样实例化模型并计算损失
model = Mnist_Logistic()
print(loss_func(model(xb), yb))
tensor(2.3313, grad_fn=<NllLossBackward0>)
我们仍然可以使用以前相同的 fit 方法。
tensor(0.0819, grad_fn=<NllLossBackward0>)
使用 torch.optim 重构¶
Pytorch 还提供了一个包含各种优化算法的包，torch.optim。我们可以使用优化器中的 step 方法向前迈进，而不是手动更新每个参数。
这将使我们能够替换之前手动编码的优化步骤
with torch.no_grad():
for p in model.parameters(): p -= p.grad * lr
model.zero_grad()
而只需使用
(optim.zero_grad() 将梯度重置为 0，我们需要在计算下一个小批次的梯度之前调用它。）
from torch import optim
我们将定义一个小的函数来创建我们的模型和优化器，以便我们将来可以重用它。
def get_model():
model = Mnist_Logistic()
return model, optim.SGD(model.parameters(), lr=lr)
model, opt = get_model()
print(loss_func(model(xb), yb))
for epoch in range(epochs):
for i in range((n - 1) // bs + 1):
start_i = i * bs
end_i = start_i + bs
xb = x_train[start_i:end_i]
yb = y_train[start_i:end_i]
pred = model(xb)
loss = loss_func(pred, yb)
loss.backward()
opt.step()
opt.zero_grad()
print(loss_func(model(xb), yb))
tensor(2.2659, grad_fn=<NllLossBackward0>)
tensor(0.0810, grad_fn=<NllLossBackward0>)
使用 Dataset 重构¶
PyTorch 有一个抽象的 Dataset 类。Dataset 可以是任何具有 __len__ 函数（由 Python 的标准 len 函数调用）和 __getitem__ 函数作为索引方式的任何东西。 本教程 演示了如何创建自定义 FacialLandmarkDataset 类作为 Dataset 的子类。
PyTorch 的 TensorDataset 是一个包装张量的 Dataset。通过定义长度和索引方式，这也为我们提供了一种迭代、索引和切片张量第一维的方法。这将使我们更容易在训练时访问独立变量和因变量。
from torch.utils.data import TensorDataset
x_train 和 y_train 都可以组合在一个 TensorDataset 中，这将更容易迭代和切片。
之前，我们必须分别迭代 x 和 y 值的小批次
现在，我们可以将这两个步骤合在一起做
tensor(0.0826, grad_fn=<NllLossBackward0>)
使用 DataLoader 重构¶
PyTorch 的 DataLoader 负责管理批次。您可以从任何 Dataset 创建 DataLoader。 DataLoader 使迭代批次变得更加容易。不用使用 train_ds[i*bs : i*bs+bs]， DataLoader 会自动为我们提供每个小批次。
from torch.utils.data import DataLoader
train_ds = TensorDataset(x_train, y_train)
train_dl = DataLoader(train_ds, batch_size=bs)
之前，我们的循环像这样迭代批次 (xb, yb)
现在，我们的循环更加简洁，因为 (xb, yb) 是从数据加载器中自动加载的
tensor(0.0818, grad_fn=<NllLossBackward0>)
得益于 PyTorch 的 nn.Module、 nn.Parameter、 Dataset 和 DataLoader，我们的训练循环现在变得非常小，更容易理解。现在，让我们尝试添加在实践中创建有效模型所需的必要基本功能。
添加验证¶
在第 1 节中，我们只是尝试为训练数据设置一个合理的训练循环。实际上，您始终应该也有一个 验证集，以确定您是否过拟合。
对训练数据进行随机排序对于防止批次之间的相关性和过拟合至关重要。另一方面，无论我们是否对验证集进行随机排序，验证损失都将相同。由于随机排序需要额外的时间，因此对验证数据进行随机排序没有任何意义。
我们将使用一个比训练集大两倍的验证集批次大小。这是因为验证集不需要反向传播，因此占用更少的内存（不需要存储梯度）。我们利用这一点来使用更大的批次大小并更快地计算损失。
train_ds = TensorDataset(x_train, y_train)
train_dl = DataLoader(train_ds, batch_size=bs, shuffle=True)
valid_ds = TensorDataset(x_valid, y_valid)
valid_dl = DataLoader(valid_ds, batch_size=bs * 2)
我们将在每个 epoch 结束时计算并打印验证损失。
(请注意，我们总是在训练之前调用 model.train()，在推理之前调用 model.eval()，因为这些被 nn.BatchNorm2d 和 nn.Dropout 等层用于确保这些不同阶段的行为适当。）
model, opt = get_model()
for epoch in range(epochs):
model.train()
for xb, yb in train_dl:
pred = model(xb)
loss = loss_func(pred, yb)
loss.backward()
opt.step()
opt.zero_grad()
model.eval()
with torch.no_grad():
valid_loss = sum(loss_func(model(xb), yb) for xb, yb in valid_dl)
print(epoch, valid_loss / len(valid_dl))
0 tensor(0.3048)
1 tensor(0.2872)
创建 fit() 和 get_data()¶
现在我们将进行一些我们自己的重构。由于我们两次执行了类似的过程来计算训练集和验证集的损失，因此让我们将其变成一个函数，loss_batch，它计算一个批次的损失。
我们为训练集传递一个优化器，并使用它来执行反向传播。对于验证集，我们不传递优化器，因此该方法不会执行反向传播。
fit 运行必要的操作来训练我们的模型并计算每个 epoch 的训练和验证损失。
import numpy as np
def fit(epochs, model, loss_func, opt, train_dl, valid_dl):
for epoch in range(epochs):
model.train()
for xb, yb in train_dl:
loss_batch(model, loss_func, xb, yb, opt)
model.eval()
with torch.no_grad():
losses, nums = zip(
*[loss_batch(model, loss_func, xb, yb) for xb, yb in valid_dl]
)
val_loss = np.sum(np.multiply(losses, nums)) / np.sum(nums)
print(epoch, val_loss)
get_data 返回训练集和验证集的数据加载器。
def get_data(train_ds, valid_ds, bs):
return (
DataLoader(train_ds, batch_size=bs, shuffle=True),
DataLoader(valid_ds, batch_size=bs * 2),
)
现在，我们的整个获取数据加载器和拟合模型的过程可以用 3 行代码完成
0 0.2939354367017746
1 0.3258970756947994
您可以使用这 3 行基本代码来训练各种模型。让我们看看我们是否可以使用它们来训练卷积神经网络 (CNN)！
切换到 CNN¶
我们现在将使用三个卷积层构建我们的神经网络。因为前一节中的任何函数都没有假设模型形式，因此我们可以使用它们来训练 CNN，而无需任何修改。
我们将使用 PyTorch 的预定义 Conv2d 类作为我们的卷积层。我们定义了一个具有 3 个卷积层的 CNN。每个卷积之后都是一个 ReLU。最后，我们执行平均池化。（请注意， view 是 PyTorch 版本的 Numpy 的 reshape）
class Mnist_CNN(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(1, 16, kernel_size=3, stride=2, padding=1)
self.conv2 = nn.Conv2d(16, 16, kernel_size=3, stride=2, padding=1)
self.conv3 = nn.Conv2d(16, 10, kernel_size=3, stride=2, padding=1)
def forward(self, xb):
xb = xb.view(-1, 1, 28, 28)
xb = F.relu(self.conv1(xb))
xb = F.relu(self.conv2(xb))
xb = F.relu(self.conv3(xb))
xb = F.avg_pool2d(xb, 4)
return xb.view(-1, xb.size(1))
lr = 0.1
动量 是随机梯度下降的一种变体，它也考虑了之前的更新，通常会导致更快的训练。
0 0.3646130460739136
1 0.26228193019628526
使用 nn.Sequential¶
torch.nn 有另一个方便的类，我们可以使用它来简化我们的代码： Sequential 。 Sequential 对象按顺序运行其包含的每个模块。这是一种更简单的方法来编写我们的神经网络。
为了利用这一点，我们需要能够从给定函数轻松地定义一个自定义层。例如，PyTorch 没有一个 view 层，我们需要为我们的网络创建一个。 Lambda 将创建一个层，然后我们可以在使用 Sequential 定义网络时使用它。
class Lambda(nn.Module):
def __init__(self, func):
super().__init__()
self.func = func
def forward(self, x):
return self.func(x)
def preprocess(x):
return x.view(-1, 1, 28, 28)
使用 Sequential 创建的模型很简单
model = nn.Sequential(
Lambda(preprocess),
nn.Conv2d(1, 16, kernel_size=3, stride=2, padding=1),
nn.ReLU(),
nn.Conv2d(16, 16, kernel_size=3, stride=2, padding=1),
nn.ReLU(),
nn.Conv2d(16, 10, kernel_size=3, stride=2, padding=1),
nn.ReLU(),
nn.AvgPool2d(4),
Lambda(lambda x: x.view(x.size(0), -1)),
)
opt = optim.SGD(model.parameters(), lr=lr, momentum=0.9)
fit(epochs, model, loss_func, opt, train_dl, valid_dl)
0 0.3330025281429291
1 0.22993727023601532
包装 DataLoader¶
- 我们的 CNN 非常简洁，但它只适用于 MNIST，因为
它假设输入是 28*28 的长向量
它假设最终的 CNN 网格大小为 4*4（因为这是我们使用的平均池化内核大小）
让我们摆脱这两个假设，这样我们的模型就可以使用任何 2d 单通道图像。首先，我们可以通过将数据预处理移动到生成器中来移除初始的 Lambda 层
def preprocess(x, y):
return x.view(-1, 1, 28, 28), y
class WrappedDataLoader:
def __init__(self, dl, func):
self.dl = dl
self.func = func
def __len__(self):
return len(self.dl)
def __iter__(self):
for b in self.dl:
yield (self.func(*b))
train_dl, valid_dl = get_data(train_ds, valid_ds, bs)
train_dl = WrappedDataLoader(train_dl, preprocess)
valid_dl = WrappedDataLoader(valid_dl, preprocess)
接下来，我们可以用 nn.AdaptiveAvgPool2d 替换 nn.AvgPool2d，它允许我们定义想要的输出张量的大小，而不是我们拥有的输入张量的大小。因此，我们的模型将适用于任何大小的输入。
model = nn.Sequential(
nn.Conv2d(1, 16, kernel_size=3, stride=2, padding=1),
nn.ReLU(),
nn.Conv2d(16, 16, kernel_size=3, stride=2, padding=1),
nn.ReLU(),
nn.Conv2d(16, 10, kernel_size=3, stride=2, padding=1),
nn.ReLU(),
nn.AdaptiveAvgPool2d(1),
Lambda(lambda x: x.view(x.size(0), -1)),
)
opt = optim.SGD(model.parameters(), lr=lr, momentum=0.9)
让我们试一试
0 0.3212135115623474
1 0.21439074140787123
使用您的 GPU¶
如果您有幸可以使用 CUDA 支持的 GPU（您可以从大多数云提供商那里以每小时约 0.50 美元的价格租用一个），那么您可以使用它来加速您的代码。首先检查您的 GPU 是否在 Pytorch 中正常工作
print(torch.cuda.is_available())
True
然后为它创建一个设备对象
dev = torch.device(
"cuda") if torch.cuda.is_available() else torch.device("cpu")
让我们更新 preprocess 以将批次移动到 GPU
最后，我们可以将模型移动到 GPU。
model.to(dev)
opt = optim.SGD(model.parameters(), lr=lr, momentum=0.9)
您应该会发现它现在运行得更快
0 0.18182211091518402
1 0.17126532876491546
结束语¶
我们现在有了通用的数据管道和训练循环，您可以使用它来训练使用 Pytorch 的许多类型的模型。要了解训练模型现在可以变得多么简单，请查看 mnist_sample 笔记本。
当然，您可能希望添加许多功能，例如数据增强、超参数调整、监控训练、迁移学习等等。这些功能在 fastai 库中可用，该库使用本教程中展示的相同设计方法开发，为希望进一步发展其模型的从业人员提供了自然的下一步。
我们在本教程的开头承诺，我们将通过示例解释 torch.nn、 torch.optim、 Dataset 和 DataLoader 的每一个。所以让我们总结一下我们所看到的
torch.nn:
Module：创建一个可调用对象，其行为类似于函数，但也可以包含状态（例如神经网络层权重）。它知道它包含的Parameter（s），并且可以将所有梯度清零，循环遍历它们以进行权重更新等等。
Parameter：张量包装器，它告诉Module它具有在反向传播期间需要更新的权重。只有具有已设置的 requires_grad 属性的张量才会更新
functional：一个模块（通常按照惯例导入到F命名空间中），它包含激活函数、损失函数等，以及卷积层和线性层等无状态层的版本。
torch.optim: 包含优化器，例如SGD，它们在反向传播步骤中更新Parameter的权重。
Dataset: 一个抽象接口，包含具有__len__和__getitem__的对象，包括 Pytorch 提供的类，例如TensorDataset。
DataLoader: 接收任何Dataset并创建一个迭代器，它返回数据批次。
脚本总运行时间: ( 0 分钟 34.801 秒)
