PyTorch教程中文版

原文：Welcome to PyTorch Tutorials — PyTorch Tutorials 1.12.0+cu102 documentation​​​​​​

 中文翻译，加个人总结，便于理解与回顾。

前置知识：python、神经网络

目录

基础概念：

张量Tensors：

 tensor的性质：

tensor的操作：

基本使用：

数据集

自定义数据集：

数据载入器

变换

搭建神经网络

模型参数：

自动微分

禁止梯度跟踪

计算图

 tensor梯度和雅各布乘积

 优化模型参数

超参数

 保存于载入模型

保存、加载模型权重

保存加载模型形状

将模型导出为ONNX

---

基础概念：

张量Tensors：

一维数组，二维矩阵，三维以上称作张量。类似于NumPy的ndarrays，只是tensor可以在GPU或其他硬件加速器上运行。事实上，tensor和NumPy数组通常可以共享相同的底层内存，不需要复制数据。tensor还为自动微分进行了优化。

#张量初始化：

#直接初始化：
data = [[1, 2], [3, 4]]
x_data = torch.tensor(data)

#从Numpy数组中初始化
np_array = np.array(data)
x_np = torch.from_numpy(np_array)

#从其他tensor中初始化
x_ones = torch.ones_like(x_data) # retains the properties of x_data
print(f"Ones Tensor: \n {x_ones} \n")

x_rand = torch.rand_like(x_data, dtype=torch.float) # overrides the datatype of x_data
print(f"Random Tensor: \n {x_rand} \n")

#使用随机数和常数初始化
shape = (2,3,)
rand_tensor = torch.rand(shape)
ones_tensor = torch.ones(shape)
zeros_tensor = torch.zeros(shape)

print(f"Random Tensor: \n {rand_tensor} \n")
print(f"Ones Tensor: \n {ones_tensor} \n")
print(f"Zeros Tensor: \n {zeros_tensor}")

 tensor的性质：

形状：tensor.shape

数据类型：tensor.dtype

存储设备：tensor.device

tensor的操作：

torch — PyTorch 1.12 documentationhttps://pytorch.org/docs/stable/torch.html全面介绍了100多种tensor操作，包括算术、线性代数、矩阵操作（转置、索引、切片）、采样等。

默认情况下，tensor是在CPU上创建的。我们需要使用.to方法明确地将tensor移动到GPU上（在检查GPU的可用性之后）。请记住，在不同的设备上复制存储size比较大的tensor，在时间和内存上都是很昂贵的!

# 如果有的话，我们把我们的tensor移到GPU上
if torch.cuda.is_available():
    tensor = tensor.to('cuda')
# 类似numpy的一系列操作：
tensor = torch.ones(4, 4)
print('第一行: ', tensor[0])
print('第一列：', tensor[:, 0])
print('最后一列：', tensor[..., -1])
tensor[:,1] = 0
print(tensor)

#连接tensor
t1 = torch.cat([tensor, tensor, tensor], dim=1)
print(t1)

# 这将计算两个tensor之间的矩阵乘法，y1, y2, y3将有相同的值
y1 = tensor @ tensor.T
y2 = tensor.matmul(tensor.T)

y3 = torch.rand_like(tensor)
torch.matmul(tensor, tensor.T, out=y3)


# 这将计算出元素相乘的结果。z1，z2, z3有相同的值
z1 = tensor * tensor
z2 = tensor.mul(tensor)

z3 = torch.rand_like(tensor)
torch.mul(tensor, tensor, out=z3)

#item()将其变换为Python数值
agg = tensor.sum()
agg_item = agg.item()
print(agg_item, type(agg_item))

# 原地操作
print(tensor, "\n")
tensor.add_(5)
print(tensor)

# 和Numpy转换
t = torch.ones(5)
print(f"t: {t}")
n = t.numpy()
print(f"n: {n}")
t.add_(1) # tensor的变化反映在NumPy数组中
print(f"t: {t}")
print(f"n: {n}")

# Numpy数组转换为tensor
n = np.ones(5)
t = torch.from_numpy(n)
np.add(n, 1, out=n) # Numpy数组中的变化反映在tensor中
print(f"t: {t}")
print(f"n: {n}")

基本使用：

数据集

torch.utils.data.Dataset

import torch
from torch.utils.data import Dataset
from torchvision import datasets
from torchvision.transforms import ToTensor
import matplotlib.pyplot as plt

# 加载数据集
training_data = datasets.FashionMNIST( root="data", train=True, download=True, transform=ToTensor() )

test_data = datasets.FashionMNIST( root="data", train=False, download=True, transform=ToTensor() )

# 数据集的迭代和可视化
labels_map = {
    0: "T-Shirt",
    1: "Trouser",
    2: "Pullover",
    3: "Dress",
    4: "Coat",
    5: "Sandal",
    6: "Shirt",
    7: "Sneaker",
    8: "Bag",
    9: "Ankle Boot",
}
figure = plt.figure(figsize=(8, 8))
cols, rows = 3, 3
for i in range(1, cols * rows + 1):
    sample_idx = torch.randint(len(training_data), size=(1,)).item()
    img, label = training_data[sample_idx]
    figure.add_subplot(rows, cols, i)
    plt.title(labels_map[label])
    plt.axis("off")
    plt.imshow(img.squeeze(), cmap="gray")
plt.show()

自定义数据集：

需要实现下面三个方法

__init__

在实例化数据集对象时，__init__函数运行一次。我们初始化目录，目录中包括图像文件、标注文件和变换（在下一节有更详细的介绍）。

__len__

函数 __len__ 返回我们数据集中的样本数。

__getitem__

函数 __getitem__ 在给定的索引idx处加载并返回数据集中的一个样本。基于索引，它确定图像在硬盘上的位置，使用read_image将其变换为tensor，从self.img_labels中的csv数据中获取相应的标签，对其调用变换函数（如果适用），并在一个元组中返回tensor图像和相应标签。

import os
import pandas as pd
from torchvision.io import read_image

class CustomImageDataset(Dataset):
    def __init__(self, annotations_file, img_dir, transform=None, target_transform=None):
        self.img_labels = pd.read_csv(annotations_file)
        self.img_dir = img_dir
        self.transform = transform
        self.target_transform = target_transform

    def __len__(self):
        return len(self.img_labels)

    def __getitem__(self, idx):
        img_path = os.path.join(self.img_dir, self.img_labels.iloc[idx, 0])
        image = read_image(img_path)
        label = self.img_labels.iloc[idx, 1]
        if self.transform:
            image = self.transform(image)
        if self.target_transform:
            label = self.target_transform(label)
        return image, label

数据载入器

torch.utils.data.DataLoader

DataLoader：数据集每次都会检索我们的数据集的特征和标签。在训练模型时，我们通常希望以 "小批 "的形式传递样本，在每个epoch中重新洗牌以减少模型的过拟合，并使用Python的multiprocessing来加快数据的检索速度。

from torch.utils.data import DataLoader

# 加载数据
train_dataloader = DataLoader(training_data, batch_size=64, shuffle=True)
test_dataloader = DataLoader(test_data, batch_size=64, shuffle=True)

# 迭代
# Display image and label.
train_features, train_labels = next(iter(train_dataloader))
print(f"Feature batch shape: {train_features.size()}")
print(f"Labels batch shape: {train_labels.size()}")
img = train_features[0].squeeze()
label = train_labels[0]
plt.imshow(img, cmap="gray")
plt.show()
print(f"Label: {label}")

变换

torchvision.transform

ToTensor：ToTensor将PIL图像或NumPy的ndarray变换为FloatTensor，并将图像的像素亮度值按[0., 1.]的范围进行缩放。

Lambda：Lambda变换应用任何用户定义的Lambda函数。在这里，我们定义了一个函数，把整数变成一个one-hot的tensor。它首先创建一个大小为10（我们数据集中的标签数量），值为0的tensor，并调用scatter_，在标签y给出的索引上分配一个value=1。

import torch
from torchvision import datasets
from torchvision.transforms import ToTensor, Lambda

ds = datasets.FashionMNIST(
    root="data",
    train=True,
    download=True,
    transform=ToTensor(),
    target_transform=Lambda(lambda y: torch.zeros(10, dtype=torch.float).scatter_(0, torch.tensor(y), value=1))
)

搭建神经网络

torch.nn

PyTorch中的每个模块都是nn.Module的子类

nn.Flatten：展平

nn.Linear：线性层，使用其存储的权重和偏置对输入进行线性变换

nn.ReLU：非线性激活函数

nn.Sequential：有序模块的容器

seq_modules = nn.Sequential(
    flatten,
    layer1,
    nn.ReLU(),
    nn.Linear(20, 10)
)
input_image = torch.rand(3,28,28)
logits = seq_modules(input_image)

 nn.Softmax：对数被缩放到数值区间[0, 1]，代表模型对每个类别的预测概率。 dim参数表示数值必须和为1的维度。

softmax = nn.Softmax(dim=1)
pred_probab = softmax(logits)

完整代码： 

import os
import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

# 获取训练的设备
device = 'cuda' if torch.cuda.is_available() else 'cpu'
print('Using {} device'.format(device))

#  定义类
class NeuralNetwork(nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__init__()
        self.flatten = nn.Flatten()
        self.linear_relu_stack = nn.Sequential(
            nn.Linear(28*28, 512),
            nn.ReLU(),
            nn.Linear(512, 512),
            nn.ReLU(),
            nn.Linear(512, 10),
        )

    def forward(self, x):
        x = self.flatten(x)
        logits = self.linear_relu_stack(x)
        return logits
# 创建一个NeuralNetwork的实例，并将其移动到设备上，并打印其结构
model = NeuralNetwork().to(device)
print(model)

使用模型时，把输入数据传给它，会自动执行forward函数，以及一些后台操作。请不要直接调用model.forward()！

X = torch.rand(1, 28, 28, device=device)
logits = model(X)
pred_probab = nn.Softmax(dim=1)(logits)
y_pred = pred_probab.argmax(1)
print(f"Predicted class: {y_pred}")

模型参数：

parameters() 或 named_parameters() 方法访问所有参数

print("Model structure: ", model, "\n\n")

for name, param in model.named_parameters():
    print(f"Layer: {name} | Size: {param.size()} | Values : {param[:2]} \n")

自动微分

torch.autograd

PyTorch有一个内置的微分引擎，它支持对任何计算图的梯度进行自动计算。

import torch

x = torch.ones(5)  # input tensor
y = torch.zeros(3)  # expected output
w = torch.randn(5, 3, requires_grad=True)
b = torch.randn(3, requires_grad=True)
z = torch.matmul(x, w)+b
loss = torch.nn.functional.binary_cross_entropy_with_logits(z, y)

print('Gradient function for z =', z.grad_fn)
print('Gradient function for loss =', loss.grad_fn)

#计算梯度
loss.backward()
print(w.grad)
print(b.grad)

• 我们只能获得计算图的叶子节点的grad属性，这些节点的requires_grad属性设置为True。对于我们图中的所有其他节点，梯度将不可用。
• 出于性能方面的考虑，我们只能在一个给定的图上使用一次backward来进行梯度计算。如果我们需要在同一个图上进行多次backward调用，我们需要在backward调用中传递 retain_graph=True。

禁止梯度跟踪

默认情况下，所有带有require_grad=True的tensor都在跟踪它们的计算历史并支持梯度计算。然而，在某些情况下，我们不需要这样做，例如，当我们已经训练好了模型，只是想把它应用于一些输入数据，也就是说，我们只想通过网络进行前向计算。我们可以通过用torch.no_grad()块包围我们的计算代码来停止跟踪计算。

z = torch.matmul(x, w)+b
print(z.requires_grad)

with torch.no_grad():
    z = torch.matmul(x, w)+b
print(z.requires_grad)

# 另一种做法
z = torch.matmul(x, w)+b
z_det = z.detach()
print(z_det.requires_grad)

禁用梯度跟踪：

• 将神经网络中的一些参数标记为冻结参数。这是对预训练的网络进行微调的一个非常常见的情况。
• 当你只做前向传递时，为了加快计算速度，对不跟踪梯度的tensor的计算会更有效率。

计算图

从概念上讲，autograd在一个由Function对象组成的有向无环图（DAG）中保存了数据（tensor）和所有执行的操作（以及产生的新tensor）的记录。在这个DAG中，叶子是输入tensor，根部是输出tensor。通过追踪这个图从根到叶，你可以使用链式规则自动计算梯度。

在一个前向传递中，autograd同时做两件事。

• 运行请求的操作，计算出一个结果tensor。
• 在DAG中维护该操作的梯度函数。

当在DAG根上调用.backward()时，后向传递开始了。

• 计算每个.grad_fn的梯度。
• 将它们累积到各自tensor的 .grad 属性中
• 使用链式规则，一直传播到叶子tensor。

注意:在PyTorch中，DAG是动态的。需要注意的是，图是从头开始重新创建的；在每次调用.backward()后，autograd开始填充一个新的图。这正是允许你在模型中使用控制流语句的原因；如果需要，你可以在每次迭代时改变形状、大小和操作。

 tensor梯度和雅各布乘积

在许多情况下，我们有一个标量损失函数，我们需要计算相对于某些参数的梯度。然而，有些情况下，输出函数是一个任意的张量。在这种情况下，PyTorch允许你计算雅各布乘积，而不是实际的梯度。

对于一个矢量函数 ，其中，和 ，一个相对于的梯度是由Jacobian矩阵给出的。

PyTorch允许你计算雅各布乘积，而不是计算雅各布矩阵本身。对于一个给定的输入矢量。 这可以通过调用v作为参数的backward来实现。v的大小应该与原始张量的大小相同，我们要进行乘积计算。

inp = torch.eye(5, requires_grad=True)
out = (inp+1).pow(2)
out.backward(torch.ones_like(inp), retain_graph=True)
print("First call\n", inp.grad)
out.backward(torch.ones_like(inp), retain_graph=True)
print("\nSecond call\n", inp.grad)
inp.grad.zero_()
out.backward(torch.ones_like(inp), retain_graph=True)
print("\nCall after zeroing gradients\n", inp.grad)

请注意，当我们第二次以相同的参数调用后向时，梯度的值是不同的。这是因为在进行向后传播时，PyTorch会累积梯度，也就是说，计算出的梯度值会加到计算图的所有叶子节点的梯度属性中。如果你想计算正确的梯度，你需要在计算梯度之前将梯度属性清零。在真实的训练中，优化器可以帮助我们做到这一点。

注意:之前我们在调用backward()函数的时候是不带参数的。这基本上等同于调用backward(torch.tensor(1.0))，这是在标量值函数的情况下计算梯度的有效方法，比如神经网络训练中的损失。

 优化模型参数

训练模型是一个迭代的过程；在每个迭代中（称为epoch），模型对输出进行猜测，计算其猜测的误差（损失），收集误差相对于其参数的导数，并使用梯度下降优化这些参数。

import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensor, Lambda

training_data = datasets.FashionMNIST(
    root="data",
    train=True,
    download=True,
    transform=ToTensor()
)

test_data = datasets.FashionMNIST(
    root="data",
    train=False,
    download=True,
    transform=ToTensor()
)

train_dataloader = DataLoader(training_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)

class NeuralNetwork(nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__init__()
        self.flatten = nn.Flatten()
        self.linear_relu_stack = nn.Sequential(
            nn.Linear(28*28, 512),
            nn.ReLU(),
            nn.Linear(512, 512),
            nn.ReLU(),
            nn.Linear(512, 10),
        )

    def forward(self, x):
        x = self.flatten(x)
        logits = self.linear_relu_stack(x)
        return logits

model = NeuralNetwork()

超参数

我们为训练定义了以下超参数：

• epoch数 - 在数据集上迭代的次数
• 批量大小--在更新参数之前，通过网络传播的数据样本的数量。
• 学习率--在每个批次epoch更新模型参数的程度。较小的值产生缓慢的学习速度，而较大的值可能会导致训练期间的不可预测的行为。

learning_rate = 1e-3
batch_size = 64
epochs = 5

优化循环的每一次迭代被称为一个epoch。
训练loop--在训练数据集上迭代，试图收敛到最佳参数。
验证/测试循环--迭代测试数据集，以检查模型性能是否在提高。

损失函数
    nn.MSELoss（均方误差）
    nn.NLLLoss（负对数似然）
    nn.LogSoftmax
    nn.CrossEntropyLoss

优化器

优化是在每个训练步骤中调整模型参数以减少模型误差的过程。
所有的优化逻辑都被封装在优化器对象中。SGD优化器；Adam和RMSProp，它们对不同类型的模型和数据有更好的效果。

调用optimizer.zero_grad()来重置模型参数的梯度。梯度默认为累加；为了防止重复计算，我们在每次迭代中明确地将其归零。
通过调用loss.backwards()对预测损失进行反向传播。PyTorch将损失的梯度与每个参数联系在一起。
一旦我们有了梯度，我们就可以调用optimizer.step()来根据向后传递中收集的梯度调整参数。

# Initialize the loss function
loss_fn = nn.CrossEntropyLoss()

optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

执行

def train_loop(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)
    for batch, (X, y) in enumerate(dataloader):
        # Compute prediction and loss
        pred = model(X)
        loss = loss_fn(pred, y)

        # Backpropagation
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        if batch % 100 == 0:
            loss, current = loss.item(), batch * len(X)
            print(f"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]")


def test_loop(dataloader, model, loss_fn):
    size = len(dataloader.dataset)
    num_batches = len(dataloader)
    test_loss, correct = 0, 0

    with torch.no_grad():
        for X, y in dataloader:
            pred = model(X)
            test_loss += loss_fn(pred, y).item()
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()

    test_loss /= num_batches
    correct /= size
    print(f"Test Error: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")

loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

epochs = 10
for t in range(epochs):
    print(f"Epoch {t+1}\n-------------------------------")
    train_loop(train_dataloader, model, loss_fn, optimizer)
    test_loop(test_dataloader, model, loss_fn)
print("Done!")

 保存于载入模型

保存、加载模型权重

import torch
import torch.onnx as onnx
import torchvision.models as models

# 保存和载入模型的权重
model = models.vgg16(pretrained=True)
torch.save(model.state_dict(), 'model_weights.pth')

# 加载模型的权重，你需要先创建一个相同模型的实例，然后用load_state_dict()方法加载参数。
model = models.vgg16() # we do not specify pretrained=True, i.e. do not load default weights
model.load_state_dict(torch.load('model_weights.pth'))
model.eval()

保存加载模型形状

在加载模型权重时，我们需要先将模型类实例化，因为该类定义了网络的结构。我们可能想把这个类的结构和模型一起保存，在这种情况下，我们可以把模型（而不是model.state_dict()）传给保存函数。

torch.save(model, 'model.pth')

model = torch.load('model.pth')

将模型导出为ONNX

PyTorch也有内置的ONNX导出支持。然而，由于PyTorch执行图的动态性质，导出过程必须遍历执行图以产生持久的ONNX模型。出于这个原因，应该向导出程序传递一个适当大小的测试变量（在我们的例子中，将创建一个正确形状且值为零的tensor）。

input_image = torch.zeros((1,3,224,224))
onnx.export(model, input_image, 'model.onnx')

后续记录强化学习与深度强化学习的pytorch使用