PyTorch 秘籍
原文：
pytorch.org/tutorials/recipes/recipes_index.html译者：飞龙
秘籍是关于如何使用特定 PyTorch 功能的简短、可操作的示例，与我们的全长教程不同。
PyTorch 原型示例
原文：
pytorch.org/tutorials/prototype/prototype_index.html译者：飞龙
原型功能不作为二进制分发的一部分，比如 PyPI 或 Conda（除非可能在运行时标志后面）。为了测试这些功能，我们会根据功能的不同，建议从主分支构建或使用在pytorch.org上提供的夜间版本。
承诺水平：我们承诺只收集关于这些功能的高带宽反馈。基于这些反馈和社区成员之间的潜在进一步互动，作为一个社区，我们将决定是否要升级承诺水平或快速失败。
PyTorch 介绍
学习基础知识
原文：
pytorch.org/tutorials/beginner/basics/intro.html译者：飞龙
注意
点击这里下载完整示例代码
学习基础知识 || 快速入门 || 张量 || 数据集和数据加载器 || 转换 || 构建模型 || 自动微分 || 优化 || 保存和加载模型
作者：Suraj Subramanian、Seth Juarez、Cassie Breviu、Dmitry Soshnikov、Ari Bornstein
大多数机器学习工作流程涉及处理数据、创建模型、优化模型参数和保存训练好的模型。本教程向您介绍了在 PyTorch 中实现的完整 ML 工作流程，并提供了有关这些概念的更多学习链接。
我们将使用 FashionMNIST 数据集训练一个神经网络，该神经网络可以预测输入图像是否属于以下类别之一：T 恤/上衣、裤子、套头衫、连衣裙、外套、凉鞋、衬衫、运动鞋、包或短靴。
本教程假定您对 Python 和深度学习概念有基本了解。
运行教程代码
您可以通过以下几种方式运行本教程：
- 在云端：这是开始的最简单方式！每个部分顶部都有一个“在 Microsoft Learn 中运行”和“在 Google Colab 中运行”的链接，分别在 Microsoft Learn 或 Google Colab 中打开一个集成的笔记本，其中包含完全托管环境中的代码。
- 本地运行：此选项要求您首先在本地计算机上设置 PyTorch 和 TorchVision（安装说明）。下载笔记本或将代码复制到您喜欢的 IDE 中。
如何使用本指南
如果您熟悉其他深度学习框架，请先查看 0. 快速入门，快速熟悉 PyTorch 的 API。
如果您是深度学习框架的新手，请直接进入我们逐步指南的第一部分：1. 张量。
- 快速入门 1. 张量 2. 数据集和数据加载器 3. 转换 4. 构建模型 5. 自动微分 6. 优化循环 7. 保存、加载和使用模型
脚本的总运行时间：（0 分钟 0.000 秒）
下载 Python 源代码：intro.py
下载 Jupyter 笔记本：intro.ipynb
快速入门
原文：
pytorch.org/tutorials/beginner/basics/quickstart_tutorial.html译者：飞龙
注意
点击这里下载完整示例代码
学习基础知识 || 快速入门 || 张量 || 数据集和数据加载器 || 转换 || 构建模型 || 自动求导 || 优化 || 保存和加载模型
本节介绍了机器学习中常见任务的 API。请参考每个部分中的链接以深入了解。
处理数据
PyTorch 有两个用于处理数据的基本方法：torch.utils.data.DataLoader和torch.utils.data.Dataset。Dataset存储样本及其对应的标签，而DataLoader将一个可迭代对象包装在Dataset周围。
import torch from torch import nn from torch.utils.data import DataLoader from torchvision import datasets from torchvision.transforms import ToTensor
PyTorch 提供了领域特定的库，如TorchText、TorchVision和TorchAudio，其中包括数据集。在本教程中，我们将使用一个 TorchVision 数据集。
torchvision.datasets模块包含许多现实世界视觉数据的Dataset对象，如 CIFAR、COCO（完整列表在此）。在本教程中，我们使用 FashionMNIST 数据集。每个 TorchVision Dataset都包括两个参数：transform和target_transform，分别用于修改样本和标签。
# Download training data from open datasets. training_data = datasets.FashionMNIST( root="data", train=True, download=True, transform=ToTensor(), ) # Download test data from open datasets. test_data = datasets.FashionMNIST( root="data", train=False, download=True, transform=ToTensor(), )
Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz to data/FashionMNIST/raw/train-images-idx3-ubyte.gz 0%| | 0/26421880 [00:00<?, ?it/s] 0%| | 65536/26421880 [00:00<01:12, 362268.71it/s] 1%| | 229376/26421880 [00:00<00:38, 680481.08it/s] 3%|3 | 819200/26421880 [00:00<00:13, 1853717.26it/s] 11%|#1 | 3014656/26421880 [00:00<00:03, 7167253.78it/s] 24%|##3 | 6258688/26421880 [00:00<00:01, 11757636.19it/s] 42%|####1 | 11075584/26421880 [00:00<00:00, 20718315.26it/s] 55%|#####4 | 14483456/26421880 [00:01<00:00, 20324854.10it/s] 74%|#######4 | 19562496/26421880 [00:01<00:00, 27572084.42it/s] 87%|########7 | 23068672/26421880 [00:01<00:00, 27527140.28it/s] 100%|#########9| 26312704/26421880 [00:01<00:00, 26297445.36it/s] 100%|##########| 26421880/26421880 [00:01<00:00, 18147607.68it/s] Extracting data/FashionMNIST/raw/train-images-idx3-ubyte.gz to data/FashionMNIST/raw Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz to data/FashionMNIST/raw/train-labels-idx1-ubyte.gz 0%| | 0/29515 [00:00<?, ?it/s] 100%|##########| 29515/29515 [00:00<00:00, 327172.52it/s] Extracting data/FashionMNIST/raw/train-labels-idx1-ubyte.gz to data/FashionMNIST/raw Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz to data/FashionMNIST/raw/t10k-images-idx3-ubyte.gz 0%| | 0/4422102 [00:00<?, ?it/s] 1%|1 | 65536/4422102 [00:00<00:11, 363567.22it/s] 5%|5 | 229376/4422102 [00:00<00:06, 694276.06it/s] 19%|#9 | 851968/4422102 [00:00<00:01, 1962897.43it/s] 64%|######3 | 2818048/4422102 [00:00<00:00, 5508389.41it/s] 100%|##########| 4422102/4422102 [00:00<00:00, 6087122.93it/s] Extracting data/FashionMNIST/raw/t10k-images-idx3-ubyte.gz to data/FashionMNIST/raw Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz to data/FashionMNIST/raw/t10k-labels-idx1-ubyte.gz 0%| | 0/5148 [00:00<?, ?it/s] 100%|##########| 5148/5148 [00:00<00:00, 36228652.67it/s] Extracting data/FashionMNIST/raw/t10k-labels-idx1-ubyte.gz to data/FashionMNIST/raw
我们将Dataset作为参数传递给DataLoader。这会将一个可迭代对象包装在我们的数据集周围，并支持自动批处理、采样、洗牌和多进程数据加载。在这里，我们定义了一个批量大小为 64，即数据加载器可迭代对象中的每个元素将返回一个包含 64 个特征和标签的批次。
batch_size = 64 # Create data loaders. train_dataloader = DataLoader(training_data, batch_size=batch_size) test_dataloader = DataLoader(test_data, batch_size=batch_size) for X, y in test_dataloader: print(f"Shape of X [N, C, H, W]: {X.shape}") print(f"Shape of y: {y.shape} {y.dtype}") break
Shape of X [N, C, H, W]: torch.Size([64, 1, 28, 28]) Shape of y: torch.Size([64]) torch.int64
阅读更多关于在 PyTorch 中加载数据。
创建模型
要在 PyTorch 中定义神经网络，我们创建一个从nn.Module继承的类。我们在__init__函数中定义网络的层，并在forward函数中指定数据如何通过网络传递。为了加速神经网络中的操作，我们将其移动到 GPU 或 MPS（如果可用）。
# Get cpu, gpu or mps device for training. device = ( "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu" ) print(f"Using {device} device") # Define model class NeuralNetwork(nn.Module): def __init__(self): super().__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().to(device) print(model)
Using cuda device NeuralNetwork( (flatten): Flatten(start_dim=1, end_dim=-1) (linear_relu_stack): Sequential( (0): Linear(in_features=784, out_features=512, bias=True) (1): ReLU() (2): Linear(in_features=512, out_features=512, bias=True) (3): ReLU() (4): Linear(in_features=512, out_features=10, bias=True) ) )
阅读更多关于在 PyTorch 中构建神经网络。
优化模型参数
loss_fn = nn.CrossEntropyLoss() optimizer = torch.optim.SGD(model.parameters(), lr=1e-3)
在单个训练循环中，模型对训练数据集进行预测（以批量方式提供），并将预测错误反向传播以调整模型的参数。
def train(dataloader, model, loss_fn, optimizer): size = len(dataloader.dataset) model.train() for batch, (X, y) in enumerate(dataloader): X, y = X.to(device), y.to(device) # Compute prediction error pred = model(X) loss = loss_fn(pred, y) # Backpropagation loss.backward() optimizer.step() optimizer.zero_grad() if batch % 100 == 0: loss, current = loss.item(), (batch + 1) * len(X) print(f"loss: {loss:>7f} [{current:>5d}/{size:>5d}]")
我们还会检查模型在测试数据集上的表现，以确保它正在学习。
def test(dataloader, model, loss_fn): size = len(dataloader.dataset) num_batches = len(dataloader) model.eval() test_loss, correct = 0, 0 with torch.no_grad(): for X, y in dataloader: X, y = X.to(device), y.to(device) 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")
训练过程是在几个迭代（epochs）中进行的。在每个迭代中，模型学习参数以做出更好的预测。我们在每个迭代中打印模型的准确性和损失；我们希望看到准确性随着每个迭代的增加而增加，损失随着每个迭代的减少而减少。
epochs = 5 for t in range(epochs): print(f"Epoch {t+1}\n-------------------------------") train(train_dataloader, model, loss_fn, optimizer) test(test_dataloader, model, loss_fn) print("Done!")
Epoch 1 ------------------------------- loss: 2.303494 [ 64/60000] loss: 2.294637 [ 6464/60000] loss: 2.277102 [12864/60000] loss: 2.269977 [19264/60000] loss: 2.254235 [25664/60000] loss: 2.237146 [32064/60000] loss: 2.231055 [38464/60000] loss: 2.205037 [44864/60000] loss: 2.203240 [51264/60000] loss: 2.170889 [57664/60000] Test Error: Accuracy: 53.9%, Avg loss: 2.168588 Epoch 2 ------------------------------- loss: 2.177787 [ 64/60000] loss: 2.168083 [ 6464/60000] loss: 2.114910 [12864/60000] loss: 2.130412 [19264/60000] loss: 2.087473 [25664/60000] loss: 2.039670 [32064/60000] loss: 2.054274 [38464/60000] loss: 1.985457 [44864/60000] loss: 1.996023 [51264/60000] loss: 1.917241 [57664/60000] Test Error: Accuracy: 60.2%, Avg loss: 1.920374 Epoch 3 ------------------------------- loss: 1.951705 [ 64/60000] loss: 1.919516 [ 6464/60000] loss: 1.808730 [12864/60000] loss: 1.846550 [19264/60000] loss: 1.740618 [25664/60000] loss: 1.698733 [32064/60000] loss: 1.708889 [38464/60000] loss: 1.614436 [44864/60000] loss: 1.646475 [51264/60000] loss: 1.524308 [57664/60000] Test Error: Accuracy: 61.4%, Avg loss: 1.547092 Epoch 4 ------------------------------- loss: 1.612695 [ 64/60000] loss: 1.570870 [ 6464/60000] loss: 1.424730 [12864/60000] loss: 1.489542 [19264/60000] loss: 1.367256 [25664/60000] loss: 1.373464 [32064/60000] loss: 1.376744 [38464/60000] loss: 1.304962 [44864/60000] loss: 1.347154 [51264/60000] loss: 1.230661 [57664/60000] Test Error: Accuracy: 62.7%, Avg loss: 1.260891 Epoch 5 ------------------------------- loss: 1.337803 [ 64/60000] loss: 1.313278 [ 6464/60000] loss: 1.151837 [12864/60000] loss: 1.252142 [19264/60000] loss: 1.123048 [25664/60000] loss: 1.159531 [32064/60000] loss: 1.175011 [38464/60000] loss: 1.115554 [44864/60000] loss: 1.160974 [51264/60000] loss: 1.062730 [57664/60000] Test Error: Accuracy: 64.6%, Avg loss: 1.087374 Done!
阅读更多关于训练模型。
保存模型
保存模型的常见方法是序列化内部状态字典（包含模型参数）。
torch.save(model.state_dict(), "model.pth") print("Saved PyTorch Model State to model.pth")
Saved PyTorch Model State to model.pth
加载模型
加载模型的过程包括重新创建模型结构并将状态字典加载到其中。
model = NeuralNetwork().to(device) model.load_state_dict(torch.load("model.pth"))
<All keys matched successfully>
现在可以使用这个模型进行预测了。
classes = [ "T-shirt/top", "Trouser", "Pullover", "Dress", "Coat", "Sandal", "Shirt", "Sneaker", "Bag", "Ankle boot", ] model.eval() x, y = test_data[0][0], test_data[0][1] with torch.no_grad(): x = x.to(device) pred = model(x) predicted, actual = classes[pred[0].argmax(0)], classes[y] print(f'Predicted: "{predicted}", Actual: "{actual}"')
Predicted: "Ankle boot", Actual: "Ankle boot"
阅读更多关于保存和加载模型。
脚本的总运行时间：（0 分钟 58.630 秒）
下载 Python 源代码：quickstart_tutorial.py
下载 Jupyter 笔记本：quickstart_tutorial.ipynb
张量
原文：
pytorch.org/tutorials/beginner/basics/tensorqs_tutorial.html译者：飞龙
注意
点击这里下载完整示例代码
学习基础知识 || 快速入门 || 张量 || 数据集和数据加载器 || 变换 || 构建模型 || 自动微分 || 优化 || 保存和加载模型
张量是一种类似于数组和矩阵的专门数据结构。在 PyTorch 中，我们使用张量来编码模型的输入和输出，以及模型的参数。
张量类似于NumPy 的 ndarrays，不同之处在于张量可以在 GPU 或其他硬件加速器上运行。实际上，张量和 NumPy 数组通常可以共享相同的基础内存，消除了复制数据的需要（请参阅与 NumPy 的桥接）。张量还针对自动微分进行了优化（我们稍后将在自动微分部分看到更多）。如果您熟悉 ndarrays，您将很容易使用张量 API。如果不熟悉，请跟着学习！
import torch import numpy as np
初始化张量
张量可以以各种方式初始化。看看以下示例：
直接从数据中
可以直接从数据创建张量。数据类型会自动推断。
data = [[1, 2],[3, 4]] x_data = torch.tensor(data)
从 NumPy 数组
可以从 NumPy 数组创建张量（反之亦然-请参阅与 NumPy 的桥接）。
np_array = np.array(data) x_np = torch.from_numpy(np_array)
从另一个张量中：
新张量保留了参数张量的属性（形状、数据类型），除非显式覆盖。
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")
Ones Tensor: tensor([[1, 1], [1, 1]]) Random Tensor: tensor([[0.8823, 0.9150], [0.3829, 0.9593]])
使用随机或常量值：
shape是张量维度的元组。在下面的函数中，它确定输出张量的维度。
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}")
Random Tensor: tensor([[0.3904, 0.6009, 0.2566], [0.7936, 0.9408, 0.1332]]) Ones Tensor: tensor([[1., 1., 1.], [1., 1., 1.]]) Zeros Tensor: tensor([[0., 0., 0.], [0., 0., 0.]])
PyTorch 2.2 中文官方教程（一）（2）https://developer.aliyun.com/article/1482477
