PyTorch 深度学习¶

# CPU 版本
pip install torch torchvision torchaudio              # 安装

# GPU 版本（CUDA 12.4）
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124

# 验证
python -c "import torch; print(torch.__version__); print(torch.cuda.is_available())"

import torch                                          # 导入 PyTorch
import torch.nn as nn                                 # 神经网络模块
import torch.optim as optim                           # 优化器
from torch.utils.data import DataLoader, TensorDataset  # 数据加载

# 张量操作
x = torch.tensor([1.0, 2.0, 3.0])                    # 创建张量
y = torch.randn(3, 4)                                # 随机张量
z = torch.zeros(2, 3).cuda()                          # GPU 上的零张量

# 自动求导
x = torch.tensor([2.0], requires_grad=True)           # 需要梯度
y = x ** 2 + 3 * x                                   # 前向计算
y.backward()                                         # 反向传播
print(x.grad)                                        # 梯度 = 2*2+3 = 7

# 定义模型
class SimpleNet(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),         # 全连接层
            nn.ReLU(),                                # 激活函数
            nn.Dropout(0.3),                          # Dropout 防过拟合
            nn.Linear(hidden_dim, output_dim)         # 输出层
        )

    def forward(self, x):
        return self.net(x)                            # 前向传播

# 训练流程
model = SimpleNet(10, 64, 2)                          # 10 输入 2 输出
criterion = nn.CrossEntropyLoss()                     # 交叉熵损失
optimizer = optim.Adam(model.parameters(), lr=0.001)  # Adam 优化器

# 准备数据
X_tensor = torch.FloatTensor(X_train)                 # 转为张量
y_tensor = torch.LongTensor(y_train)                  # 标签张量
dataset = TensorDataset(X_tensor, y_tensor)           # 创建数据集
loader = DataLoader(dataset, batch_size=32, shuffle=True)  # 数据加载器

# 训练循环
for epoch in range(100):
    model.train()                                     # 训练模式
    total_loss = 0
    for batch_x, batch_y in loader:                   # 遍历批次
        optimizer.zero_grad()                         # 清零梯度
        outputs = model(batch_x)                      # 前向传播
        loss = criterion(outputs, batch_y)            # 计算损失
        loss.backward()                               # 反向传播
        optimizer.step()                              # 更新参数
        total_loss += loss.item()
    if epoch % 10 == 0:
        print(f"Epoch {epoch}, Loss: {total_loss/len(loader):.4f}")

# 预测
model.eval()                                          # 评估模式
with torch.no_grad():                                 # 不计算梯度
    predictions = model(torch.FloatTensor(X_test))    # 预测
    predicted_class = predictions.argmax(dim=1)       # 取最大概率类别

# PyTorch 2.0+ 编译加速
compiled_model = torch.compile(model)                 # 一行代码加速
# 之后正常使用 compiled_model 即可，速度提升 30-200%

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = model.to(device)                              # 模型移到 GPU

for batch_x, batch_y in loader:
    batch_x = batch_x.to(device)                      # 数据移到 GPU
    batch_y = batch_y.to(device)
    outputs = model(batch_x)
    # ... 训练步骤

# 保存
torch.save(model.state_dict(), 'model.pth')           # 保存参数

# 加载
model = SimpleNet(10, 64, 2)
model.load_state_dict(torch.load('model.pth'))        # 加载参数
model.eval()                                          # 切换到评估模式

# === 核心流程 ===
# 1. 定义模型（nn.Module）
# 2. 定义损失函数（nn.CrossEntropyLoss）
# 3. 定义优化器（optim.Adam）
# 4. 训练循环：forward → loss → backward → step
# 5. 评估：model.eval() + torch.no_grad()

# === 常用层 ===
nn.Linear(in, out)        # 全连接
nn.Conv2d(in, out, k)     # 卷积
nn.LSTM(in, hidden)       # LSTM
nn.BatchNorm1d(n)         # 批归一化
nn.Dropout(p)             # Dropout

# === 设备管理 ===
.to(device)               # 移动到设备
.cuda() / .cpu()          # GPU / CPU
torch.cuda.is_available() # 检查 GPU