PyTorch深度学习框架核心概念精讲

1. PyTorch 是一个开源的深度学习框架
2. PyTorch 主要有以下几个基础概念：

张量（Tensor）：PyTorch 的核心数据结构，支持多维数组，并可以在 CPU 或 GPU 上进行加速计算。

**自动求导：**PyTorch提供了自动求导功能，可以轻松计算模型的梯度，便于进行反向传播和优化

神经网络 ：神经网络 是一种模仿人类大脑神经元结构的人工智能算法模型，也是深度学习的核心，擅长从数据里自动学习规律、完成识别、分类、预测等任务。

神经网络的基本结构（三层核心）

1. 输入层 接收原始数据，比如图片像素、文字、声音、数值等。
2. 隐藏层 （核心） 多层虚拟神经元对数据层层加工、提取特征 。 比如识别猫：先识别线条→轮廓→耳朵 / 眼睛→最终判断是猫。 层数越多，就是常说的深度神经网络（深度学习）。
3. 输出层 给出最终结果：分类（猫 / 狗）、预测（股价）、生成内容等。

# 导入数学计算库
import numpy as np

# 1. 定义一个简单的激活函数（让神经元能学习复杂特征）
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# 2. 创建 3 层神经网络
class SimpleNeuralNetwork:
    def __init__(self):
        # --------------------------
        # 【输入层 → 隐藏层】权重
        # 3 个输入 → 4 个隐藏神经元
        # --------------------------
        self.w1 = np.random.rand(3, 4)

        # --------------------------
        # 【隐藏层 → 输出层】权重
        # 4 个隐藏神经元 → 1 个输出
        # --------------------------
        self.w2 = np.random.rand(4, 1)

    # 前向传播：数据一层层流过网络
    def forward(self, x):
        # 输入层 → 隐藏层
        hidden = np.dot(x, self.w1)
        hidden = sigmoid(hidden)

        # 隐藏层 → 输出层
        output = np.dot(hidden, self.w2)
        output = sigmoid(output)

        return output

# -------------------
# 测试神经网络
# -------------------
nn = SimpleNeuralNetwork()

# 输入数据（3个数值，对应【输入层】）
input_data = np.array([0.2, 0.3, 0.4])

# 神经网络计算结果
result = nn.forward(input_data)

print("输入数据：", input_data)
print("神经网络输出结果：", result)

1. 优化器（Optimizers）：使用优化器（如 Adam、SGD 等）来更新模型的参数，使得损失最小化。
2. 设备（Device）：可以将模型和张量移动到 GPU 上以加速计算。

PyTorch 架构总览

PyTorch 采用模块化设计，由多个相互协作的核心组件构成。理解这些组件的作用和相互关系，是掌握 PyTorch 的关键。

PyTorch生态系统

torchvision：计算机视觉（CV）库名一般叫（cv2），做图像识别、目标检测、图像分割，用torchvision

它能做什么？

• 自带现成的经典 CV 模型（ResNet、YOLO、ViT、Faster R-CNN 等）
• 图片预处理、数据增强（裁剪、旋转、归一化等）
• 加载常用图像数据集（CIFAR10、ImageNet、COCO 等）
• 图像转换工具

torchtext：自然语言处理（NLP），专门处理：文本、句子、单词数据。

它能做什么？

• 文本分词、构建词汇表
• 文本转数字索引、生成批次数据
• 加载常用 NLP 数据集（IMDB、SST、WikiText 等）
• 文本预处理流水线

torchaudio：语音识别 / 语音处理 / 音频处理，专门处理：声音、语音、波形数据

它能做什么？

• 音频加载、波形处理
• 语音特征提取（MFCC、梅尔频谱）
• 语音增强、降噪
• 加载语音数据集（LibriSpeech 等）
• 预训练语音模型

PyTorch核心

torch.nn ：

专门用来搭建神经网络层和模型的模块。

• 核心功能：
  • 内置各种常用层：全连接层（Linear）、卷积层（Conv2d）、循环层（LSTM）、激活函数（ReLU、Sigmoid）等。
  • 容器类：nn.Module 作为所有模型的基类，nn.Sequential 用来快速搭建顺序结构模型。
  • 损失函数：交叉熵损失（CrossEntropyLoss）、均方误差（MSELoss）等。
• 总结：搭模型、写网络结构，基本都靠它。

import torch
import torch.nn as nn

# ====================== 1. 用 nn.Module 定义模型 ======================
class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        
        # 内置网络层
        self.conv = nn.Conv2d(3, 16, 3)    # 卷积层
        self.relu = nn.ReLU()              # 激活函数
        self.flatten = nn.Flatten()        # 展平
        self.fc = nn.Linear(16*30*30, 10)  # 全连接层

    # 前向传播（数据怎么走）
    def forward(self, x):
        x = self.conv(x)
        x = self.relu(x)
        x = self.flatten(x)
        x = self.fc(x)
        return x

# ====================== 2. 用 nn.Sequential 快速搭模型 ======================
model_seq = nn.Sequential(
    nn.Conv2d(3, 16, 3),
    nn.ReLU(),
    nn.Flatten(),
    nn.Linear(16*30*30, 10)
)

# ====================== 3. 损失函数 ======================
loss_fn = nn.CrossEntropyLoss()  # 分类任务
# loss_fn = nn.MSELoss()         # 回归任务

# ====================== 测试 ======================
model = MyModel()
test_input = torch.randn(1, 3, 32, 32)  # 模拟一张 32x32 的彩色图
output = model(test_input)
print("模型输出 shape:", output.shape)  # 输出：torch.Size([1, 10])

torch.optim ：

PyTorch 框架中专门用于实现优化算法的核心库 ，它的作用是自动更新神经网络的参数（权重、偏置），让模型通过训练不断降低损失、提升精度。

常用优化器（内置在 torch.optim 中）：

|-----------------------|--------------------|--------------------|
| 优化器 | 特点 | 适用场景 |
| torch.optim.SGD | 随机梯度下降，最简单、最基础 | 大部分基础模型、教学场景 |
| torch.optim.Adam | 自适应学习率，收敛快、效果稳 | 最常用，图像、文本、语音通用 |
| torch.optim.RMSprop | 适合循环神经网络（RNN/LSTM） | 时序数据、NLP 任务 |
| torch.optim.Adagrad | 自适应学习率，适合稀疏数据 | 推荐系统、稀疏特征场景 |

import torch
import torch.nn as nn

# 1. 定义模型 + 损失函数
model = nn.Linear(10, 1)  # 示例模型
criterion = nn.MSELoss()

# 2. 初始化优化器（传入模型参数 + 学习率）
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

# 训练循环
for epoch in range(100):
    # 前向传播：计算预测值和损失
    outputs = model(torch.randn(32, 10))
    loss = criterion(outputs, torch.randn(32, 1))
    
    # 3. 清空梯度（必须！否则梯度会累加）
    optimizer.zero_grad()
    
    # 反向传播：计算梯度
    loss.backward()
    
    # 4. 更新参数（核心步骤）
    optimizer.step()

• **optimizer.zero_grad()**清空上一步的梯度，PyTorch 会默认累加梯度，不清空会导致训练出错。
• loss.backward() 计算所有参数的梯度（求导）。
• optimizer.step() 根据梯度，自动更新模型的权重和偏置。

torch.utils ：

PyTorch 里的 "实用工具大合集" ，它不是一个单独的功能，而是把训练模型时最常用、最繁琐的辅助功能 打包在一起，让你不用自己造轮子，简单说就是 PyTorch 的工具箱，帮你处理数据、加速训练、做调试、保存进度等。

最核心、最常用的 4 个子模块（必须掌握）

1. torch.utils.data（最最重要）

专门用来加载、批量、打乱数据 ，是训练神经网络的数据入口。

里面最常用的两个类：

• Dataset：自定义你的数据集（图片、文本、表格都行）
• DataLoader：自动批量加载、打乱、多线程加速

几乎所有 PyTorch 项目都会用：

from torch.utils.data import Dataset, DataLoader

# 用 DataLoader 批量喂数据，自动打乱、自动分批次
dataloader = DataLoader(dataset, batch_size=32, shuffle=True)

---

2.torch.utils.tensorboard

训练可视化工具，能画：

• 损失 loss 曲线
• 准确率曲线
• 权重分布
• 生成图像、模型结构

from torch.utils.tensorboard import SummaryWriter
writer = SummaryWriter()
writer.add_scalar("loss", loss, epoch)

---

3. torch.utils.model_zoo

自动下载预训练模型权重（不用自己找链接、下载）

from torch.utils.model_zoo import load_url

---

4. **torch.utils.checkpoint节省显存神器：**用计算换内存，适合训练超大模型。

超简示例：自定义数据集 + DataLoader

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

# 1. 自定义一个数据集
class MyDataset(Dataset):
    # 初始化数据
    def __init__(self):
        # 造100个样本数据
        self.data = torch.arange(100)  # [0,1,2,...,99]

    # 返回数据长度
    def __len__(self):
        return len(self.data)

    # 根据索引取数据
    def __getitem__(self, idx):
        return self.data[idx]

# 2. 创建数据集
dataset = MyDataset()

# 3. 用 DataLoader 自动分批、打乱
dataloader = DataLoader(
    dataset,
    batch_size=10,  # 每批10个数据
    shuffle=True    # 打乱顺序
)

# 4. 遍历查看效果
print("分批后的数据：")
for batch in dataloader:
    print(batch)