深度学习—PyTorch基础

PyTorch 是由 Facebook 人工智能研究院（FAIR）开发的开源深度学习框架，基于 Python 和 C++ 实现，于 2016 年正式发布。其核心特点是。

.官方小助手

1088人浏览 · 2025-06-12 21:24:03

.官方小助手 · 2025-06-12 21:24:03 发布

PyTorch 深度学习框架详解

一、PyTorch 概述

PyTorch 是由 Facebook 人工智能研究院（FAIR）开发的开源深度学习框架，基于 Python 和 C++ 实现，于 2016 年正式发布。其核心特点是动态计算图和易用性，广泛应用于学术研究和工业界，尤其在自然语言处理、计算机视觉、强化学习等领域表现突出。

主要优势：

动态图机制：支持实时修改计算图，便于调试和灵活建模。
Python 优先：完全集成 Python 生态，开发效率高。
强大的 GPU 加速：支持 CUDA 和 ROCm，适配主流显卡。
丰富的扩展库：TorchVision（视觉）、TorchText（文本）、TorchScript（模型部署）等。

二、PyTorch 核心概念与组件

1. 张量（Tensor）

PyTorch 的基础数据结构，类似多维数组，支持 CPU 和 GPU 计算。

常用操作示例：

python

import torch

# 创建张量
x = torch.tensor([1, 2, 3])  # 一维张量
y = torch.zeros((3, 4))     # 3x4全0张量
z = torch.randn(2, 2, 2)    # 2x2x2正态分布随机张量

# 张量运算
a = torch.tensor([[1, 2], [3, 4]])
b = torch.tensor([[5, 6], [7, 8]])
c = a + b  # 加法
d = torch.matmul(a, b)  # 矩阵乘法

# 设备迁移
if torch.cuda.is_available():
    a = a.cuda()  # 移至GPU
    b = b.cuda()

2. 自动微分（Autograd）

PyTorch 通过torch.autograd模块实现自动求导，核心是Variable（已整合到张量中）和计算图。

关键概念：

requires_grad：张量属性，设为True时跟踪其计算历史。
grad：反向传播后存储梯度值。
backward()：触发反向传播，计算梯度。

示例：计算 y = (x+3)² 的导数

python

x = torch.tensor(2.0, requires_grad=True)
y = (x + 3) ** 2
y.backward()  # 反向传播
print(x.grad)  # 输出：10.0（即dy/dx=2*(2+3)=10）

3. 动态计算图

与 TensorFlow 的静态图不同，PyTorch 的计算图在运行时动态构建，支持条件语句和循环，灵活性更高。

对比示例：

python

# PyTorch动态图（支持运行时修改）
def dynamic_graph(x):
    if x.shape[0] > 1:
        return x.sum()
    else:
        return x.mean()

# TensorFlow静态图（需预先定义图结构）
# （此处省略TensorFlow代码，仅示意差异）

4. 模型构建：nn.Module

通过继承nn.Module类定义神经网络，需重写__init__和forward方法。

简单神经网络示例：

python

import torch.nn as nn
import torch.nn.functional as F

class SimpleNet(nn.Module):
    def __init__(self):
        super(SimpleNet, self).__init__()
        self.fc1 = nn.Linear(784, 256)  # 全连接层
        self.fc2 = nn.Linear(256, 10)   # 输出层（10分类）
    
    def forward(self, x):
        x = x.view(-1, 784)  # 展平输入
        x = F.relu(self.fc1(x))  # ReLU激活
        x = self.fc2(x)
        return F.log_softmax(x, dim=1)  # 输出概率

三、PyTorch 工作流程

1. 数据准备

使用torch.utils.data.Dataset和DataLoader加载数据。
支持数据增强（如 TorchVision 的Transforms）。

MNIST 数据集加载示例：

python

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

# 数据预处理
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])

# 加载训练集和测试集
train_dataset = datasets.MNIST('data/', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST('data/', train=False, transform=transform)

# 创建数据加载器
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=64)

2. 模型训练

定义模型、损失函数（如nn.CrossEntropyLoss）和优化器（如torch.optim.Adam）。
循环迭代训练，包含前向传播、损失计算、反向传播和参数更新。

训练循环示例：

python

model = SimpleNet()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

# 移至GPU（如果可用）
if torch.cuda.is_available():
    model = model.cuda()
    criterion = criterion.cuda()

# 训练模型
epochs = 5
for epoch in range(epochs):
    model.train()  # 启用训练模式
    for batch_idx, (data, target) in enumerate(train_loader):
        if torch.cuda.is_available():
            data, target = data.cuda(), target.cuda()
        
        # 前向传播
        optimizer.zero_grad()  # 清空梯度
        output = model(data)
        loss = criterion(output, target)
        
        # 反向传播和优化
        loss.backward()
        optimizer.step()
        
        # 打印训练进度
        if batch_idx % 100 == 0:
            print(f'Epoch: {epoch+1}/{epochs}, Batch: {batch_idx}, Loss: {loss.item():.4f}')

3. 模型评估与保存

使用model.eval()关闭正则化（如 Dropout）。
保存模型参数（推荐）或完整模型。

评估与保存示例：

python

# 评估模型
model.eval()
correct = 0
with torch.no_grad():  # 不计算梯度，节省内存
    for data, target in test_loader:
        if torch.cuda.is_available():
            data, target = data.cuda(), target.cuda()
        output = model(data)
        pred = output.argmax(dim=1, keepdim=True)
        correct += pred.eq(target.view_as(pred)).sum().item()

print(f'测试准确率: {100. * correct / len(test_dataset):.2f}%')

# 保存模型（推荐仅保存参数）
torch.save(model.state_dict(), 'simplenet.pth')

# 加载模型
loaded_model = SimpleNet()
loaded_model.load_state_dict(torch.load('simplenet.pth'))

四、PyTorch 高级特性

1. 分布式训练

通过torch.distributed模块支持多 GPU 和多节点训练，常用方法：

数据并行（DataParallel）：单节点多 GPU，自动拆分数据。
分布式数据并行（DistributedDataParallel, DDP）：多节点高效训练，通信更优。

DDP 初始化示例：

python

import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP

# 初始化分布式环境
dist.init_process_group(backend='nccl', init_method='env://')
local_rank = torch.distributed.get_rank()
torch.cuda.set_device(local_rank)

# 模型移至对应GPU并包裹DDP
model = model.cuda(local_rank)
model = DDP(model, device_ids=[local_rank])

2. 混合精度训练

使用torch.cuda.amp模块加速训练，减少内存占用：

python

from torch.cuda.amp import autocast, GradScaler

scaler = GradScaler()

for epoch in range(epochs):
    for data, target in train_loader:
        data, target = data.cuda(), target.cuda()
        
        optimizer.zero_grad()
        with autocast():  # 自动转换为半精度
            output = model(data)
            loss = criterion(output, target)
        
        scaler.scale(loss).backward()  # 缩放损失以防止溢出
        scaler.step(optimizer)
        scaler.update()

3. TorchScript 与模型部署

TorchScript：将 PyTorch 模型转换为可序列化的中间表示，支持 C++ 部署。
ONNX 格式：导出为开放神经网络交换格式，兼容多种框架。

TorchScript 转换示例：

python

# 追踪模型（适用于无控制流的模型）
traced_model = torch.jit.trace(model, data)
traced_model.save('model_traced.pt')

# 或脚本化模型（支持控制流）
scripted_model = torch.jit.script(model)
scripted_model.save('model_scripted.pt')

五、PyTorch 生态与对比

1. 主流框架对比

框架	PyTorch	TensorFlow/Keras	JAX
计算图	动态图（默认）	静态图（TensorFlow）/ 动态图（Keras）	静态图（编译优化）
灵活性	高（适合研究）	中（适合工程）	高（函数式编程）
部署支持	TorchScript/ONNX	TensorFlow Serving	TPU/XLA
社区	学术社区活跃	工业界应用广泛	新兴科研框架