PyTorch 详细知识点总结

news/2025/4/1 6:23:55/

PyTorch 详细知识点总结

1. PyTorch 基础概念

1.1 张量（Tensor）

  • 张量是PyTorch中的基本数据结构
  • 类似于多维数组，支持GPU加速
  • 主要操作：
    python">import torch# 创建张量
x = torch.tensor([1, 2, 3])
y = torch.zeros(2, 3)
z = torch.randn(3, 4)# 张量运算
a = x + y
b = torch.matmul(y, z)
c = x.mean()

1.2 自动求导（Autograd）

  • PyTorch的核心功能，用于自动计算梯度
  • 通过计算图实现反向传播
  • 示例：
    python">x = torch.ones(2, 2, requires_grad=True)
y = x + 2
z = y * y
z.backward(torch.ones_like(z))
print(x.grad)  # 打印梯度

2. 神经网络构建

2.1 nn.Module

  • PyTorch中构建神经网络的基类
  • 包含网络层定义和前向传播
  • 示例：
    python">import torch.nn as nnclass Net(nn.Module):def __init__(self):super(Net, self).__init__()self.fc1 = nn.Linear(784, 128)self.fc2 = nn.Linear(128, 10)self.relu = nn.ReLU()def forward(self, x):x = self.relu(self.fc1(x))x = self.fc2(x)return x

2.2 常用层

  • Linear：全连接层
  • Conv2d：2D卷积层
  • MaxPool2d：最大池化层
  • BatchNorm2d：批归一化
  • Dropout：防止过拟合

3. 数据处理

3.1 Dataset和DataLoader

  • Dataset：定义数据集
  • DataLoader：批量加载数据
  • 示例：
    python">from torch.utils.data import Dataset, DataLoaderclass CustomDataset(Dataset):def __init__(self, data, labels):self.data = dataself.labels = labelsdef __len__(self):return len(self.data)def __getitem__(self, idx):return self.data[idx], self.labels[idx]# 创建数据加载器
dataset = CustomDataset(data, labels)
dataloader = DataLoader(dataset, batch_size=32, shuffle=True)

4. 模型训练

4.1 优化器和损失函数

  • 常用优化器：SGD、Adam
  • 常用损失函数：CrossEntropyLoss、MSELoss
  • 示例：
    python">criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)# 训练循环
for epoch in range(num_epochs):for data, labels in dataloader:optimizer.zero_grad()outputs = model(data)loss = criterion(outputs, labels)loss.backward()optimizer.step()

4.2 模型保存与加载

python"># 保存模型
torch.save(model.state_dict(), 'model.pth')# 加载模型
model.load_state_dict(torch.load('model.pth'))

5. GPU加速

5.1 设备管理

python">device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = model.to(device)
data = data.to(device)

6. 高级特性

6.1 分布式训练

  • DistributedDataParallel：多GPU训练
  • DataParallel：简单的数据并行

6.2 TorchScript

  • 将PyTorch模型转换为可优化的格式
  • 支持在生产环境中部署

6.3 模型量化

  • 减少模型大小和推理时间
  • 支持动态量化和静态量化

7. 调试与优化

7.1 内存优化

  • 使用del释放不需要的张量
  • 使用torch.no_grad()减少内存使用
  • 梯度累积处理大批量数据

7.2 性能分析

  • torch.autograd.profiler
  • nvprof性能分析
  • 内存泄漏检测

8. 最佳实践

8.1 代码规范

  • 使用nn.Sequential组织网络层
  • 适当使用nn.ModuleList和nn.ParameterList
  • 正确处理batch维度

8.2 训练技巧

  • 学习率调度
  • 早停策略
  • 模型集成
  • 交叉验证

8.3 部署考虑

  • 模型导出（ONNX）
  • 服务化部署
  • 移动端部署
  • 边缘设备部署

9. 常见问题解决方案

9.1 数据预处理

python"># 图像数据预处理
from torchvision import transformstransform = transforms.Compose([transforms.Resize((224, 224)),transforms.ToTensor(),transforms.Normalize(mean=[0.485, 0.456, 0.406],std=[0.229, 0.224, 0.225])
])# 文本数据预处理
from torch.nn.utils.rnn import pad_sequencedef text_preprocess(text_list, vocab):# 文本转换为索引indices = [[vocab[word] for word in text.split()] for text in text_list]# 填充序列padded = pad_sequence([torch.tensor(x) for x in indices], batch_first=True)return padded

9.2 模型评估

python">def evaluate_model(model, test_loader, criterion, device):model.eval()total_loss = 0correct = 0total = 0with torch.no_grad():for data, target in test_loader:data, target = data.to(device), target.to(device)output = model(data)total_loss += criterion(output, target).item()pred = output.argmax(dim=1, keepdim=True)correct += pred.eq(target.view_as(pred)).sum().item()total += target.size(0)avg_loss = total_loss / len(test_loader)accuracy = 100. * correct / totalreturn avg_loss, accuracy

9.3 早停策略实现

python">class EarlyStopping:def __init__(self, patience=7, min_delta=0):self.patience = patienceself.min_delta = min_deltaself.counter = 0self.best_loss = Noneself.early_stop = Falsedef __call__(self, val_loss):if self.best_loss is None:self.best_loss = val_losselif val_loss > self.best_loss - self.min_delta:self.counter += 1if self.counter >= self.patience:self.early_stop = Trueelse:self.best_loss = val_lossself.counter = 0

9.4 模型训练监控

python">class TrainingMonitor:def __init__(self):self.history = {'train_loss': [],'val_loss': [],'accuracy': []}def update(self, metrics):for k, v in metrics.items():self.history[k].append(v)def plot_metrics(self):epochs = range(1, len(self.history['train_loss']) + 1)plt.figure(figsize=(12, 4))plt.subplot(1, 2, 1)plt.plot(epochs, self.history['train_loss'], 'b-', label='Training Loss')plt.plot(epochs, self.history['val_loss'], 'r-', label='Validation Loss')plt.title('Training and Validation Loss')plt.xlabel('Epochs')plt.ylabel('Loss')plt.legend()plt.subplot(1, 2, 2)plt.plot(epochs, self.history['accuracy'], 'g-', label='Accuracy')plt.title('Model Accuracy')plt.xlabel('Epochs')plt.ylabel('Accuracy')plt.legend()plt.tight_layout()plt.show()

9.5 实际应用场景示例

python"># 1. 迁移学习示例
from torchvision.models import resnet50def create_transfer_model(num_classes):model = resnet50(pretrained=True)# 冻结预训练参数for param in model.parameters():param.requires_grad = False# 修改最后一层model.fc = nn.Linear(model.fc.in_features, num_classes)return model# 2. 模型集成示例
class EnsembleModel(nn.Module):def __init__(self, models):super().__init__()self.models = nn.ModuleList(models)def forward(self, x):outputs = [model(x) for model in self.models]return torch.stack(outputs).mean(0)# 3. 自定义损失函数示例
class FocalLoss(nn.Module):def __init__(self, alpha=1, gamma=2):super().__init__()self.alpha = alphaself.gamma = gammadef forward(self, inputs, targets):ce_loss = F.cross_entropy(inputs, targets, reduction='none')pt = torch.exp(-ce_loss)focal_loss = self.alpha * (1-pt)**self.gamma * ce_lossreturn focal_loss.mean()

total_loss = 0
correct = 0
total = 0with torch.no_grad():for data, targets in test_loader:data, targets = data.to(device), targets.to(device)outputs = model(data)loss = criterion(outputs, targets)total_loss += loss.item()_, predicted = outputs.max(1)total += targets.size(0)correct += predicted.eq(targets).sum().item()accuracy = 100. * correct / total
avg_loss = total_loss / len(test_loader)
return avg_loss, accuracy


### 9.3 常见错误处理
```python
# 1. CUDA内存不足
try:# 较大的批量处理output = model(large_input)
except RuntimeError as e:if "out of memory" in str(e):# 清理缓存torch.cuda.empty_cache()# 减小批量大小重试output = model(large_input.split(2))# 2. 梯度爆炸处理
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)# 3. 模型并行化错误处理
if torch.cuda.device_count() > 1:try:model = nn.DataParallel(model)except RuntimeError as e:print(f"并行化失败: {e}")# 回退到单GPUmodel = model.to(device)

9.4 性能优化技巧

python"># 1. 使用混合精度训练
from torch.cuda.amp import autocast, GradScalerscaler = GradScaler()for data, targets in train_loader:with autocast():output = model(data)loss = criterion(output, targets)scaler.scale(loss).backward()scaler.step(optimizer)scaler.update()# 2. 数据加载优化
train_loader = DataLoader(dataset,batch_size=32,shuffle=True,num_workers=4,  # 多进程加载pin_memory=True  # GPU训练时使用锁页内存
)# 3. 模型推理优化
with torch.no_grad():model.eval()# 使用torch.jit.trace编译模型traced_model = torch.jit.trace(model, torch.randn(1, 3, 224, 224))output = traced_model(input_data)

9.5 实际应用场景示例

python"># 1. 迁移学习示例
from torchvision.models import resnet50def create_transfer_model(num_classes):model = resnet50(pretrained=True)# 冻结预训练参数for param in model.parameters():param.requires_grad = False# 修改最后一层model.fc = nn.Linear(model.fc.in_features, num_classes)return model# 2. 模型集成示例
class EnsembleModel(nn.Module):def __init__(self, models):super().__init__()self.models = nn.ModuleList(models)def forward(self, x):outputs = [model(x) for model in self.models]return torch.stack(outputs).mean(0)# 3. 自定义损失函数示例
class FocalLoss(nn.Module):def __init__(self, alpha=1, gamma=2):super().__init__()self.alpha = alphaself.gamma = gammadef forward(self, inputs, targets):ce_loss = F.cross_entropy(inputs, targets, reduction='none')pt = torch.exp(-ce_loss)focal_loss = self.alpha * (1-pt)**self.gamma * ce_lossreturn focal_loss.mean()# 4. 注意力机制实现
class SelfAttention(nn.Module):def __init__(self, dim):super().__init__()self.query = nn.Linear(dim, dim)self.key = nn.Linear(dim, dim)self.value = nn.Linear(dim, dim)def forward(self, x):q = self.query(x)k = self.key(x)v = self.value(x)scores = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(q.size(-1))attention = F.softmax(scores, dim=-1)return torch.matmul(attention, v)# 5. GAN实现示例
class Generator(nn.Module):def __init__(self, latent_dim, img_shape):super().__init__()self.model = nn.Sequential(nn.Linear(latent_dim, 128),nn.LeakyReLU(0.2),nn.Linear(128, 256),nn.BatchNorm1d(256),nn.LeakyReLU(0.2),nn.Linear(256, np.prod(img_shape)),nn.Tanh())self.img_shape = img_shapedef forward(self, z):img = self.model(z)return img.view(img.size(0), *self.img_shape)class Discriminator(nn.Module):def __init__(self, img_shape):super().__init__()self.model = nn.Sequential(nn.Linear(np.prod(img_shape), 256),nn.LeakyReLU(0.2),nn.Linear(256, 128),nn.LeakyReLU(0.2),nn.Linear(128, 1),nn.Sigmoid())def forward(self, img):img_flat = img.view(img.size(0), -1)return self.model(img_flat)

10. 高级训练技巧

10.1 梯度累积

python">accumulation_steps = 4  # 累积4个批次
optimizer.zero_grad()for i, (data, target) in enumerate(train_loader):output = model(data)loss = criterion(output, target) / accumulation_stepsloss.backward()if (i + 1) % accumulation_steps == 0:optimizer.step()optimizer.zero_grad()

10.2 学习率调度

python"># 1. 余弦退火调度
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=200)# 2. 带热重启的余弦退火
scheduler = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer, T_0=50, T_mult=2)# 3. One-Cycle学习率
scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer,max_lr=0.1,steps_per_epoch=len(train_loader),epochs=num_epochs
)

10.3 模型蒸馏

python">class DistillationLoss(nn.Module):def __init__(self, alpha=0.5, temperature=2.0):super().__init__()self.alpha = alphaself.T = temperaturedef forward(self, student_outputs, teacher_outputs, targets):# 硬目标损失hard_loss = F.cross_entropy(student_outputs, targets)# 软目标损失soft_loss = nn.KLDivLoss(reduction='batchmean')(F.log_softmax(student_outputs/self.T, dim=1),F.softmax(teacher_outputs/self.T, dim=1)) * (self.T * self.T)return self.alpha * hard_loss + (1-self.alpha) * soft_loss

10.4 对抗训练

python">def fgsm_attack(model, loss, data, epsilon, data_grad):# 收集数据梯度的符号sign_data_grad = data_grad.sign()# 创建扰动样本perturbed_data = data + epsilon * sign_data_grad# 添加剪裁以维持[0,1]范围perturbed_data = torch.clamp(perturbed_data, 0, 1)return perturbed_datadef train_with_adversarial(model, train_loader, optimizer, epsilon):for data, target in train_loader:# 正常训练optimizer.zero_grad()output = model(data)loss = F.cross_entropy(output, target)loss.backward()# 生成对抗样本data_grad = data.grad.dataperturbed_data = fgsm_attack(model, loss, data, epsilon, data_grad)# 对抗训练output = model(perturbed_data)loss = F.cross_entropy(output, target)loss.backward()optimizer.step()

10.5 半精度训练

python"># 1. 自动混合精度训练
scaler = torch.cuda.amp.GradScaler()
optimizer = torch.optim.Adam(model.parameters())for data, target in train_loader:optimizer.zero_grad()# 自动转换为半精度with torch.cuda.amp.autocast():output = model(data)loss = criterion(output, target)# 缩放损失以防止梯度下溢scaler.scale(loss).backward()scaler.step(optimizer)scaler.update()# 2. 手动转换为半精度
model.half()  # 转换模型参数为FP16
for data, target in train_loader:data = data.half()  # 输入数据转换为FP16output = model(data)loss = criterion(output, target)

http://www.ppmy.cn/news/1584112.html

相关文章

EventEmitter--Node.js 事件驱动的核心

EventEmitter--Node.js 事件驱动的核心

一、介绍 Node.js 中的许多对象都会分发事件，例如： net.Server 对象在每次有新连接时触发事件。 fs.readStream 对象在文件被打开时触发事件。 所有这些事件对象都是 events.EventEmitter 的实例。EventEmitter 是 Node.js 中用于创建、注册和触发事件…
阅读更多...
如何快速看懂并修改神经网络

如何快速看懂并修改神经网络

前言：个人之见，一个神经网络网络源码出现，你先看数据集的输入和输出,而这数据集肯定要包括数据增加和制作数据集，第二 看模型的输入和输出（至于模型内部可以自己看论文 无非就是加了几个组件），然…
阅读更多...
第十四届蓝桥杯大赛软件赛省赛C/C++ 大学 B 组（部分题解）

第十四届蓝桥杯大赛软件赛省赛C/C++ 大学 B 组（部分题解）

文章目录 前言日期统计题意： 冶炼金属题意： 岛屿个数题意： 子串简写题意： 整数删除题意： 总结 前言 一年一度的🏀杯马上就要开始了，为了取得更好的成绩，好名字写了下前年2023年蓝桥…
阅读更多...
【Linux】System V共享内存：零拷贝加速进程通信！

【Linux】System V共享内存：零拷贝加速进程通信！

引言 本文深入探讨System V IPC中的共享内存技术，涵盖其原理、操作步骤、实现细节及与其他IPC机制的关系，助力读者全面掌握这一高效进程间通信方式。 📝 文章总结： 共享内存原理 System V共享内存通过让多个进程共享同一物理内存区…
阅读更多...
Avro 批量转换成 Json 文件

Avro 批量转换成 Json 文件

环境准备 1. java 运行环境 2. avro-tools.jar (版本不关心，演示使用 avro-tools-1.10.2.jar)目录 avro（要转换的avro文件） json（转换后的json） avro-tools-1.10.2.jar 批量转换处理.bat (创建脚本并将下面的代码粘入…
阅读更多...
Python命名规范与代码最优结构规范：提升PyCharm中的可读性与健壮性

Python命名规范与代码最优结构规范：提升PyCharm中的可读性与健壮性

Python代码规范指南：提升PyCharm中的可读性与健壮性 一个函数只做一件事，不超过150行，函数之间空两行，不要有报黄波浪线，命名规范，注意命名规范，不要想当然认为代码出什么问题要以实测为核心找…
阅读更多...
qwen2.5vl技术报告解读

qwen2.5vl技术报告解读

一. 首先qwen2.5vl模型特点 全能文档解析能力 升级文本识别至全场景文档解析，擅长处理多场景、多语种及复杂版式文档（含手写体、表格、图表、化学方程式、乐谱等），实现跨类型文档的精准解析。 跨格式精准目标定位 突破格式限制，大幅提升对象检测、坐标定位与数量统计精度，…
阅读更多...
全链路压测：性能测试的流量录制和回放

全链路压测：性能测试的流量录制和回放

全链路压测是一种模拟真实用户操作场景，对整个系统进行压力测试的方法，旨在评估系统在高负载下的性能表现。​在全链路压测中，流量录制与回放技术起着关键作用，能够捕获并重现真实的用户流量，帮助发现潜在的性能瓶颈和…
阅读更多...
最新文章

Copyright @ 2022~2023