哪些Python案例展示了PyTorch用法？

本文目录导读：

1. 基础：线性回归（自动求导与优化器）
2. 计算机视觉：CIFAR-10图像分类（卷积神经网络）
3. 自然语言处理：情感分类（RNN/LSTM）
4. 生成模型：GAN生成手写数字（DCGAN核心）
5. 迁移学习：使用预训练ResNet进行图像分类
6. 自定义数据集和DataLoader
7. 关键PyTorch特性在上述案例中的体现：

线性回归（自动求导与优化器）

展示PyTorch的自动微分和优化器API。

import torch
import torch.nn as nn
import torch.optim as optim
# 生成模拟数据
x = torch.randn(100, 1)
y = 3 * x + 2 + 0.1 * torch.randn(100, 1)
# 定义模型
model = nn.Linear(1, 1)
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)
# 训练
for epoch in range(1000):
    pred = model(x)
    loss = criterion(pred, y)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    if epoch % 200 == 0:
        print(f'Epoch {epoch}, Loss: {loss.item():.4f}')
print(f'Final weight: {model.weight.item():.4f}, bias: {model.bias.item():.4f}')

计算机视觉：CIFAR-10图像分类（卷积神经网络）

展示卷积、池化、数据加载器和GPU加速。

import torch
import torch.nn as nn
import torchvision
import torchvision.transforms as transforms
# 准备数据
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)
# 定义简单CNN
class SimpleCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 32, 3)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(32, 64, 3)
        self.fc1 = nn.Linear(64 * 6 * 6, 128)
        self.fc2 = nn.Linear(128, 10)
    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        x = torch.flatten(x, 1)
        x = torch.relu(self.fc1(x))
        return self.fc2(x)
model = SimpleCNN()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
# 训练（假设有GPU）
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)
for epoch in range(5):
    running_loss = 0.0
    for images, labels in trainloader:
        images, labels = images.to(device), labels.to(device)
        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    print(f'Epoch {epoch+1}, Loss: {running_loss/len(trainloader):.4f}')

自然语言处理：情感分类（RNN/LSTM）

展示循环神经网络处理序列数据。

import torch
import torch.nn as nn
# 简化的评论数据（索引序列）
texts = [torch.randint(0, 1000, (20,)), torch.randint(0, 1000, (15,))]
labels = torch.tensor([1, 0])  # 1正面, 0负面
# 定义LSTM分类器
class LSTMClassifier(nn.Module):
    def __init__(self, vocab_size, embed_dim, hidden_dim, num_classes):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim)
        self.lstm = nn.LSTM(embed_dim, hidden_dim, batch_first=True)
        self.fc = nn.Linear(hidden_dim, num_classes)
    def forward(self, x):
        embedded = self.embedding(x)
        _, (hidden, _) = self.lstm(embedded)
        return self.fc(hidden[-1])
model = LSTMClassifier(vocab_size=1000, embed_dim=50, hidden_dim=64, num_classes=2)
# 训练时需要padding和pack_padded_sequence（此处简化）
# 实际应使用 torch.nn.utils.rnn.pad_sequence 和 pack_padded_sequence

生成模型：GAN生成手写数字（DCGAN核心）

展示生成对抗网络的生成器和判别器。

import torch
import torch.nn as nn
# 生成器（从噪声生成28x28图像）
class Generator(nn.Module):
    def __init__(self, latent_dim=100):
        super().__init__()
        self.model = nn.Sequential(
            nn.Linear(latent_dim, 256),
            nn.ReLU(),
            nn.Linear(256, 512),
            nn.ReLU(),
            nn.Linear(512, 784),
            nn.Tanh()
        )
    def forward(self, z):
        return self.model(z).view(-1, 1, 28, 28)
# 判别器（判断图像真假）
class Discriminator(nn.Module):
    def __init__(self):
        super().__init__()
        self.model = nn.Sequential(
            nn.Linear(784, 512),
            nn.LeakyReLU(0.2),
            nn.Linear(512, 256),
            nn.LeakyReLU(0.2),
            nn.Linear(256, 1),
            nn.Sigmoid()
        )
    def forward(self, img):
        img_flat = img.view(img.size(0), -1)
        return self.model(img_flat)

迁移学习：使用预训练ResNet进行图像分类

展示torchvision.models和fine-tuning。

import torchvision.models as models
# 加载预训练ResNet18
model = models.resnet18(pretrained=True)
# 冻结所有层
for param in model.parameters():
    param.requires_grad = False
# 替换最后的全连接层（假设自己的数据集有10类）
num_features = model.fc.in_features
model.fc = nn.Linear(num_features, 10)
# 只训练最后的分类层
optimizer = optim.Adam(model.fc.parameters(), lr=0.001)
# ... 训练代码同案例2

自定义数据集和DataLoader

展示如何加载自定义数据（如图片文件夹）。

from torch.utils.data import Dataset, DataLoader
from PIL import Image
import os
class MyImageDataset(Dataset):
    def __init__(self, root_dir, transform=None):
        self.root_dir = root_dir
        self.transform = transform
        self.images = [f for f in os.listdir(root_dir) if f.endswith('.jpg')]
    def __len__(self):
        return len(self.images)
    def __getitem__(self, idx):
        img_path = os.path.join(self.root_dir, self.images[idx])
        image = Image.open(img_path).convert('RGB')
        if self.transform:
            image = self.transform(image)
        label = 0  # 简化，实际可从文件名或子文件夹获取
        return image, label
# 使用
transform = transforms.Compose([transforms.Resize((224, 224)), transforms.ToTensor()])
dataset = MyImageDataset('./my_images', transform=transform)
dataloader = DataLoader(dataset, batch_size=32, shuffle=True)

关键PyTorch特性在上述案例中的体现：

这些案例覆盖了PyTorch最常用的功能：自动微分、模块化网络、数据加载、GPU加速和预训练模型调用,适合作为学习和实践的起点。