一个月玩转 PyTorch：从 Tensor 到模型部署的 30 天全攻略-优快云博客

欢迎来到 PyTorch 的世界！

第一周：奠定基础 (The Foundation)

第 1 天：初识 PyTorch 与张量 (Tensor)

核心概念:
- PyTorch 是什么？ 一个基于 Python 的开源机器学习库，广泛用于计算机视觉和自然语言处理等领域。其核心是动态计算图，让模型构建和调试变得直观。
- 张量 (Tensor): PyTorch 的核心数据结构。你可以把它看作是多维数组，与 NumPy 的 ndarray 非常相似，但它可以在 GPU 上运行以加速计算。

代码例子:

import torch
import numpy as np

# 打印 PyTorch 版本
print(f"PyTorch Version: {torch.__version__}")

# 创建一个 2x3 的张量
x = torch.tensor([[1, 2, 3], [4, 5, 6]])
print(f"A 2x3 Tensor:\n {x}")

# 从 NumPy 数组创建张量
np_array = np.array([[7, 8], [9, 10]])
y = torch.from_numpy(np_array)
print(f"Tensor from NumPy array:\n {y}")

# 检查张量的属性
print(f"Tensor shape: {x.shape}")
print(f"Tensor datatype: {x.dtype}")
print(f"Device tensor is stored on: {x.device}")

第 2 天：张量的创建与类型

核心概念: 学习创建不同形状和内容的张量是基础中的基础。你可以创建未初始化的、随机的、全零或全一的张量，并可以指定数据类型（如 float32, int64）。

代码例子:

import torch

# 创建一个指定形状的随机张量
rand_tensor = torch.rand(2, 3)
print(f"Random Tensor:\n {rand_tensor}")

# 创建一个全零张量
zeros_tensor = torch.zeros(2, 3, dtype=torch.long)
print(f"Zeros Tensor (long):\n {zeros_tensor}")

# 创建一个全一张量，并使用 .new_ones() 保持其属性
ones_tensor = torch.ones(2, 3)
like_ones_tensor = torch.ones_like(ones_tensor) # 形状和类型与 ones_tensor 相同
print(f"Ones-like Tensor:\n {like_ones_tensor}")

第 3 天：张量操作：索引、切片与数学运算

核心概念: 像操作 NumPy 数组一样对张量进行索引和切片。PyTorch 支持丰富的数学运算，包括逐元素运算、矩阵乘法等。

代码例子:

import torch

t = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# 索引 (获取第一行)
print(f"First row: {t[0]}")

# 切片 (获取最后一列)
print(f"Last column: {t[:, -1]}")

# 数学运算
# 逐元素加法
print(f"Addition:\n {t.add(10)}")
# 矩阵乘法
print(f"Matrix multiplication:\n {t.matmul(t.T)}") # t.T 是 t 的转置

第 4 天：张量变形与拼接

核心概念: 改变张量的形状（view, reshape）和将多个张量合并（cat, stack）是构建复杂网络时的常用操作。

代码例子:

import torch

t = torch.randn(2, 3)

# 使用 view 改变形状 (view 共享底层数据)
view_t = t.view(3, 2)
print(f"Original shape: {t.shape}, Viewed shape: {view_t.shape}")

# 使用 reshape 改变形状 (功能更强大，不一定共享数据)
reshape_t = t.reshape(6)
print(f"Reshaped to 1D: {reshape_t}")

# 沿维度 0 (行) 拼接
cat_t_0 = torch.cat([t, t, t], dim=0)
print(f"Concatenated (dim=0) shape: {cat_t_0.shape}")

# 沿维度 1 (列) 拼接
cat_t_1 = torch.cat([t, t, t], dim=1)
print(f"Concatenated (dim=1) shape: {cat_t_1.shape}")

第 5 天：自动求导 (Autograd)

核心概念: 这是 PyTorch 的魔法核心。当张量的 requires_grad 属性为 True 时，PyTorch 会追踪在其上的所有操作。完成计算后，你可以调用 .backward() 来自动计算所有梯度，梯度值会累积到 .grad 属性中。

代码例子:

import torch

# 创建一个需要梯度的张量
x = torch.ones(2, 2, requires_grad=True)
print(f"x:\n {x}")

# 对 x 进行操作
y = x + 2
z = y * y * 3
out = z.mean()

print(f"y:\n {y}")
print(f"z:\n {z}")
print(f"out: {out}")

# 计算梯度
out.backward()

# 打印 x 的梯度 d(out)/dx
print(f"Gradient of x:\n {x.grad}")

第 6 天：用张量和 Autograd 实现线性回归

核心概念: 将前面学到的知识结合起来，手动实现一个简单的机器学习模型。理解如何定义模型、计算损失、使用梯度进行参数更新。

代码例子:

import torch

# 准备数据
X = torch.tensor([[1.0], [2.0], [3.0], [4.0]])
Y = torch.tensor([[2.0], [4.0], [6.0], [8.0]])

# 初始化权重 w 和偏置 b
w = torch.tensor([[0.0]], requires_grad=True)
b = torch.tensor([[0.0]], requires_grad=True)

learning_rate = 0.01

# 训练 20 次
for epoch in range(20):
    # 1. 前向传播：计算预测值
    y_pred = X.matmul(w) + b

    # 2. 计算损失 (均方误差)
    loss = (y_pred - Y).pow(2).mean()

    # 3. 反向传播：计算梯度
    loss.backward()

    # 4. 更新权重 (使用 torch.no_grad() 避免更新操作被追踪)
    with torch.no_grad():
        w -= learning_rate * w.grad
        b -= learning_rate * b.grad

        # 清零梯度，为下一次迭代做准备
        w.grad.zero_()
        b.grad.zero_()

    if (epoch+1) % 5 == 0:
        print(f'Epoch {epoch+1}: Loss = {loss.item():.4f}, w = {w.item():.4f}, b = {b.item():.4f}')

第 7 天：复习与 GPU 加速

核心概念:
- 回顾第一周内容：张量、操作、Autograd。
- 学习如何利用 GPU 进行计算。使用 .to(device) 方法可以将张量或模型移动到指定的设备（CPU 或 GPU）上。

代码例子:

import torch

# 检查是否有可用的 GPU
device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"Using {device} device")

# 创建一个在 CPU 上的张量
cpu_tensor = torch.randn(3, 3)
print(f"CPU Tensor device: {cpu_tensor.device}")

# 将张量移动到 GPU
if device == "cuda":
    gpu_tensor = cpu_tensor.to(device)
    print(f"GPU Tensor device: {gpu_tensor.device}")

    # 在 GPU 上进行计算
    result = gpu_tensor + gpu_tensor
    print(f"Result on GPU:\n {result}")

    # 将结果移回 CPU
    cpu_result = result.to("cpu")
    print(f"Result back on CPU:\n {cpu_result}")

第二周：构建神经网络 (Building Neural Networks)

第 8 天：`torch.nn` 与 `nn.Module`

核心概念: torch.nn 是 PyTorch 用于构建神经网络的模块。所有的网络模型都应该继承 nn.Module。这使得管理模型的参数、层级结构变得非常方便。

代码例子:

import torch
from torch import nn

class MyFirstNetwork(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, 10)
        )

    def forward(self, x):
        # 定义数据如何通过网络流动 (前向传播)
        x = self.flatten(x)
        logits = self.linear_relu_stack(x)
        return logits

model = MyFirstNetwork()
print(model)

第 9 天：定义一个简单的全连接网络

核心概念: 深入理解如何使用 nn.Linear（全连接层）和激活函数（如 nn.ReLU）来搭建一个基础的神经网络。

代码例子:

import torch
from torch import nn

# 模拟一个输入数据 (batch_size=1, channels=1, height=28, width=28)
input_image = torch.rand(1, 1, 28, 28)

model = MyFirstNetwork() # 使用前一天的模型
logits = model(input_image)
print(f"Model output (logits): {logits}")

第 10 天：损失函数 (Loss Functions)

核心概念: 损失函数衡量模型输出与真实标签之间的差距。回归任务常用 nn.MSELoss (均方误差)，分类任务常用 nn.CrossEntropyLoss (交叉熵损失)。

代码例子:

import torch
from torch import nn

# 模拟模型输出和真实标签
pred = torch.randn(10, 10) # 10个样本，10个类别
target = torch.randint(0, 10, (10,)) # 10个真实标签

# 均方误差损失
mse_loss_fn = nn.MSELoss()
mse_loss = mse_loss_fn(pred, torch.randn(10, 10)) # MSE通常用于回归
print(f"MSE Loss: {mse_loss.item()}")

# 交叉熵损失 (常用于多分类)
ce_loss_fn = nn.CrossEntropyLoss()
ce_loss = ce_loss_fn(pred, target)
print(f"Cross-Entropy Loss: {ce_loss.item()}")

第 11 天：优化器 (Optimizers)

核心概念: 优化器根据损失函数计算出的梯度来更新模型的参数（权重和偏置）。常用优化器有 torch.optim.SGD（随机梯度下降）和 torch.optim.Adam。

代码例子:

import torch
from torch import nn, optim

model = MyFirstNetwork() # 假设这是我们的模型

# 定义优化器 (Adam 是一个非常流行的选择)
optimizer = optim.Adam(model.parameters(), lr=1e-3)

# 在训练循环中，你会这样做：
# 1. zero the gradients
optimizer.zero_grad()

# 2. get model output and calculate loss
# loss = loss_fn(pred, target)

# 3. run backpropagation
# loss.backward()

# 4. update the weights
# optimizer.step()

第 12 天：完整的训练循环

核心概念: 将模型、损失函数和优化器组合在一起，形成一个完整的训练流程：前向传播 -> 计算损失 -> 清零梯度 -> 反向传播 -> 更新参数。

代码例子:

# 伪代码，展示完整的训练循环结构
model = MyFirstNetwork()
loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

# 假设 data_loader 是你的数据加载器
for epoch in range(num_epochs):
    for batch, (X, y) in enumerate(data_loader):
        # 1. 前向传播
        pred = model(X)

        # 2. 计算损失
        loss = loss_fn(pred, y)

        # 3. 反向传播和优化
        optimizer.zero_grad() # 清零梯度
        loss.backward()     # 计算梯度
        optimizer.step()      # 更新权重

        if batch % 100 == 0:
            print(f"Epoch {epoch+1}, Batch {batch}: Loss={loss.item()}")

第 13 天：Dataset 与 DataLoader

核心概念: 为了高效地处理数据，PyTorch 提供了 Dataset 和 DataLoader。Dataset 负责封装和访问单个数据点，DataLoader 则负责批量（batching）、打乱（shuffling）和并行加载数据。

代码例子:

import torch
from torch.utils.data import Dataset, DataLoader

class CustomDataset(Dataset):
    def __init__(self, data, labels):
        self.data = data
        self.labels = labels

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

    def __getitem__(self, idx):
        return self.data[idx], self.labels[idx]

# 假设有数据
data = torch.randn(1000, 28*28)
labels = torch.randint(0, 10, (1000,))

dataset = CustomDataset(data, labels)
data_loader = DataLoader(dataset, batch_size=64, shuffle=True)

# 在训练循环中直接迭代 data_loader
for X, y in data_loader:
    # X 的 shape 将是 [64, 784], y 的 shape 是 [64]
    pass

第 14 天：实战项目：Fashion-MNIST 分类

核心概念: 综合运用第二周的所有知识，使用 torchvision 加载 Fashion-MNIST 数据集，构建、训练和评估一个完整的图像分类模型。

代码例子:

# 此代码较长，仅展示核心结构
import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensor

# 1. 加载数据
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)

# 2. 定义模型 (同第8天)
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, 10))
    def forward(self, x):
        x = self.flatten(x)
        return self.linear_relu_stack(x)
model = NeuralNetwork()

# 3. 定义损失和优化器
loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)

# 4. 训练和测试循环 (此处省略具体实现)
# train_loop(train_dataloader, model, loss_fn, optimizer)
# test_loop(test_dataloader, model, loss_fn)

第三周：深入高级架构 (Advanced Architectures)

第 15 天：卷积神经网络 (CNN) - 理论

核心概念: 学习 CNN 的核心组件：卷积层（Convolutional Layer）、池化层（Pooling Layer）和通道（Channels）。理解它们如何从图像中提取特征，如边缘、纹理等。

代码例子: (概念日，无完整代码)

# 关键模块
import torch.nn as nn
conv_layer = nn.Conv2d(in_channels=1, out_channels=16, kernel_size=5, stride=1, padding=2)
pool_layer = nn.MaxPool2d(kernel_size=2, stride=2)

第 16 天：构建一个 CNN 模型

核心概念: 使用 nn.Conv2d 和 nn.MaxPool2d 层来构建一个 CNN。理解卷积操作后张量尺寸的变化。

代码例子:

import torch
from torch import nn

class CNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv_stack = nn.Sequential(
            nn.Conv2d(1, 16, kernel_size=3, padding=1), # 28x28 -> 28x28
            nn.ReLU(),
            nn.MaxPool2d(2), # 28x28 -> 14x14
            nn.Conv2d(16, 32, kernel_size=3, padding=1), # 14x14 -> 14x14
            nn.ReLU(),
            nn.MaxPool2d(2) # 14x14 -> 7x7
        )
        self.flatten = nn.Flatten()
        self.fc_stack = nn.Sequential(
            nn.Linear(32 * 7 * 7, 128),
            nn.ReLU(),
            nn.Linear(128, 10)
        )

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

model = CNN()
print(model)

第 17 天：使用 CNN 训练 CIFAR-10

核心概念: 将 CNN 模型应用于更复杂的彩色图像数据集 CIFAR-10。注意输入通道数的变化（从 1 变为 3）。

代码例子: (类似于第14天，但数据集和模型会改变)

from torchvision import datasets
from torchvision.transforms import transforms

# 数据预处理，包括标准化
transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

# 加载 CIFAR-10 (输入通道为 3)
train_data = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
# ... 然后创建 DataLoader, 实例化 CNN 模型 (in_channels=3), 开始训练

第 18 天：循环神经网络 (RNN) - 理论

核心概念: 学习 RNN 如何处理序列数据（如文本、时间序列）。理解其核心思想：隐藏状态（hidden state）在时间步之间的传递。

代码例子: (概念日，无完整代码)

# 关键模块
import torch.nn as nn
rnn_layer = nn.RNN(input_size=10, hidden_size=20, num_layers=2, batch_first=True)
# batch_first=True 让输入和输出张量的第一维是 batch size

第 19 天：构建 RNN/LSTM 模型

核心概念: 使用 nn.RNN 或更强大的 nn.LSTM (长短期记忆网络) 构建模型。理解它们的输入和输出形状 (batch, seq_len, features)。

代码例子:

import torch
from torch import nn

class SimpleRNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super().__init__()
        self.hidden_size = hidden_size
        self.rnn = nn.RNN(input_size, hidden_size, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        # x shape: (batch, seq_len, input_size)
        # h0 shape: (num_layers, batch, hidden_size)
        h0 = torch.zeros(1, x.size(0), self.hidden_size).to(x.device)
        out, _ = self.rnn(x, h0)
        # 取最后一个时间步的输出
        out = self.fc(out[:, -1, :])
        return out

model = SimpleRNN(input_size=10, hidden_size=20, output_size=5)
print(model)

第 20 天：正则化与 Dropout

核心概念: 学习防止模型过拟合的技术。
- Dropout: 在训练期间以一定概率随机将神经元的输出置为零。
- L2 正则化 (Weight Decay): 在优化器中设置 weight_decay 参数，惩罚过大的权重。

代码例子:

import torch.nn as nn
import torch.optim as optim

# 在模型中加入 Dropout
model_with_dropout = nn.Sequential(
    nn.Linear(784, 256),
    nn.ReLU(),
    nn.Dropout(0.5), # 50% 的概率丢弃
    nn.Linear(256, 10)
)

# 在优化器中加入 L2 正则化
optimizer = optim.Adam(model_with_dropout.parameters(), lr=1e-3, weight_decay=1e-5)

第 21 天：保存和加载模型

核心概念: 学习如何保存和加载训练好的模型。torch.save 可以保存整个模型或只保存模型的状态字典（state_dict，推荐）。torch.load 和 model.load_state_dict() 用于加载。

代码例子:

import torch
import torch.nn as nn

model = CNN() # 假设这是我们训练好的模型
# 1. 保存模型的状态字典
torch.save(model.state_dict(), 'cnn_model_weights.pth')

# 2. 加载模型
new_model = CNN() # 首先要创建一个模型的实例
new_model.load_state_dict(torch.load('cnn_model_weights.pth'))
new_model.eval() # 切换到评估模式 (这很重要，会关闭 dropout 等)

第四周：迈向实战与部署 (Production & Deployment)

第 22 天：迁移学习 (Transfer Learning)

核心概念: 不从零开始训练，而是使用在大型数据集（如 ImageNet）上预训练好的模型。可以进行特征提取（冻结大部分层）或微调（用较小的学习率训练所有层）。

代码例子:

import torch
import torchvision.models as models

# 加载一个预训练的 ResNet18 模型
resnet = models.resnet18(weights=models.ResNet18_Weights.DEFAULT)

# 冻结所有参数
for param in resnet.parameters():
    param.requires_grad = False

# 替换最后一层以适应我们自己的分类任务 (例如 100 个类别)
num_ftrs = resnet.fc.in_features
resnet.fc = torch.nn.Linear(num_ftrs, 100)

# 现在只有最后一层的参数会被训练

第 23 天：迁移学习实战

核心概念: 将前一天的理论应用于实践，例如，在一个小型的自定义花卉或动物数据集上微调一个预训练的 ResNet。
代码例子: (概念，总结)

第 24 天：使用 TensorBoard 可视化

核心概念: TensorBoard 是一个强大的可视化工具，可以用来监控训练过程中的损失、准确率、网络图、图像等。PyTorch 通过 torch.utils.tensorboard.SummaryWriter 与其集成。

代码例子:

from torch.utils.tensorboard import SummaryWriter

# 在训练脚本开始时
writer = SummaryWriter('runs/fashion_mnist_experiment_1')

# 在训练循环中记录损失
# ...
# loss = loss_fn(pred, y)
writer.add_scalar('training loss', loss.item(), epoch * len(dataloader) + batch)
# ...

# 训练结束后关闭 writer
writer.close()

第 25 天：初探 Transformer (理论)

核心概念: 了解 Transformer 架构及其核心机制——自注意力（Self-Attention）。这是目前 NLP（如BERT, GPT）和越来越多视觉任务的基础。
代码例子: (概念日，无完整代码，因为从头实现很复杂)

第 26 天：使用 Hugging Face Transformers 库

核心概念: Hugging Face 的 transformers 库极大地简化了 Transformer 模型的使用。学习如何加载预训练的 BERT 或 GPT 模型并用其进行推理。

代码例子:

from transformers import pipeline

# 加载一个用于情感分析的预训练模型 pipeline
classifier = pipeline('sentiment-analysis')

result = classifier('I love using PyTorch and Hugging Face!')
print(result)
# 输出: [{'label': 'POSITIVE', 'score': 0.999...}]

第 27 天：模型部署入门：TorchScript

核心概念: 为了让模型能在非 Python 环境（如 C++, 移动端）中运行，PyTorch 提供了 TorchScript。它将 PyTorch 模型转换成一个可以被序列化和优化的静态图表示。

代码例子:

import torch
# 假设 model 是我们训练好的 CNN 模型
model.eval()
example_input = torch.rand(1, 1, 28, 28) # 需要一个示例输入

# 使用 tracing 转换模型
traced_script_module = torch.jit.trace(model, example_input)
traced_script_module.save("traced_cnn_model.pt")

第 28 天：模型部署：使用 Flask 封装成 API

核心概念: 将训练好的模型（无论是普通模型还是 TorchScript 模型）包装成一个 Web API，使其可以通过 HTTP 请求被调用。Flask 是一个轻量级的 Python Web 框架，非常适合此任务。

代码例子:

# app.py
from flask import Flask, request, jsonify
import torch
model = torch.jit.load('traced_cnn_model.pt') # 加载 TorchScript 模型
app = Flask(__name__)
@app.route('/predict', methods=['POST'])
def predict():
   # ... 获取和预处理输入数据 ...
    output = model(input_tensor)
     # ... 返回预测结果 ...
     return jsonify({'prediction': '...'})

第 29 天：探索 PyTorch 生态系统

核心概念: 了解 PyTorch 周边的重要库：
- torchvision: 包含流行数据集、模型架构和图像转换。
- torchaudio: 用于音频处理。
- torchtext: 用于文本处理（现在推荐使用 Hugging Face）。
- PyTorch Lightning: 一个高级封装，能极大简化训练代码。
代码例子: (无，本日以了解和探索为主)

第 30 天：总结与未来之路

核心概念:
- 恭喜你！ 您已经完成了 30 天的挑战，从零基础掌握了 PyTorch 的核心技能。
- 下一步去哪里？
  - 参与 Kaggle 竞赛: 在真实数据集上磨练你的技能。
  - 复现论文: 挑选一篇你感兴趣的论文，尝试用 PyTorch 复现其模型。
  - 深入特定领域: 深入研究计算机视觉、NLP、强化学习等。
  - 贡献开源项目: 为 PyTorch 或其生态系统中的库贡献代码。
- 学习永无止境，享受创造的乐趣！