PyTorch学习

阶段 类/概念 描述
基础

torch.Tensor 学习如何创建和操作张量（Tensor），这是PyTorch的基本数据结构。

torch.nn.Module 理解神经网络模块的基础，几乎所有模型都是基于这个类构建的。
进阶

torch.nn.Linear 学习简单的线性层，作为了解更复杂层的基础。

torch.optim.Optimizer 了解不同的优化器，如SGD、Adam等，它们用于更新网络权重。

torch.utils.data.Dataset & DataLoader 学习如何加载和处理数据集。
高级

torch.nn.Conv2d, torch.nn.MaxPool2d 学习卷积层和池化层，这些是构建CNN的关键组件。

torchvision.models 探索预训练模型，了解迁移学习的应用。

torch.nn.Sequential 学习如何快速搭建顺序模型。
专家

自定义 nn.Module 子类 创建自定义层或模型，深入理解模型构建过程。

torch.autograd 深入了解自动微分机制，这对于实现自定义层和损失函数非常重要。

分布式训练相关类 如torch.nn.parallel.DistributedDataParallel，学习大规模模型训练。

一、基础

1.torch.Tensor类

torch.Tensor 简介

torch.Tensor 是 PyTorch 中用于表示多维数组（张量）的核心数据结构，支持在 CPU 和 GPU 上进行高效计算，并具备自动微分功能。
基本特性

多维数组：可表示标量（0维）、向量（1维）、矩阵（2维）及更高维数据。
数据类型支持：如 float32、float64、int32、bool 等。
设备支持：可在 CPU 或 CUDA GPU 上存储和运算。
自动求导：若 requires_grad=True，则支持自动微分。

创建方式

可通过多种函数创建 Tensor，如：

torch.tensor()
torch.zeros(), torch.ones()
torch.empty(), torch.full()
torch.arange(), torch.linspace()
torch.rand(), torch.randn()

常用属性

.shape / .size()：返回张量形状。
.dtype：数据类型。
.device：所在设备（CPU/GPU）。
.requires_grad：是否需要梯度。
.grad：存储梯度值（若启用自动求导）。

常用方法分类

1. 形状操作

   .view(), .reshape()

   .transpose(), .permute()

   .unsqueeze(), .squeeze()

   .expand(), .repeat()

2. 数据类型与设备转换

   .to()

   .type(), .float(), .int(), .double() 等

   .cpu(), .cuda()

3. 数学运算

   基本运算：+, -, *, /, **

   函数形式：torch.add(), torch.mul() 等

   聚合操作：.sum(), .mean(), .max(), .min(), .std()

   矩阵运算：.matmul(), .mm(), .bmm()

4. 索引与切片

   支持 NumPy 风格的索引、切片、高级索引。

   .index_select(), .masked_select(), .gather()

5. 自动微分相关

   .backward()：反向传播计算梯度。

   .detach()：断开计算图。

   .clone()：复制张量（保留梯度信息）。

   .requires_grad_()：原地设置是否需要梯度。

6. 其他实用方法

   .item()：标量张量转 Python 数值。

   .tolist()：转为 Python 列表。

   .numpy()：转为 NumPy 数组（仅限 CPU 张量）。

   .copy_()：原地复制数据。

   .fill_(), .zero_(), .normal_() 等原地初始化方法。

注意事项

大多数以 _ 结尾的方法为原地操作（in-place），会修改原始张量。
使用自动求导时，避免对 requires_grad=True 的张量进行原地操作，可能导致梯度计算错误。
张量与 NumPy 数组共享内存（仅限 CPU），修改一方会影响另一方。

2.torch.nn.Module类

torch.nn.Module 类简介

torch.nn.Module 是 PyTorch 中所有神经网络模块的基类。用户自定义的模型、层或复杂网络结构通常通过继承 nn.Module 来实现。
核心作用

提供模型结构的组织方式。
自动管理可学习参数（Parameter）和子模块（Submodule）。
支持设备迁移（如 .to(device)）、状态保存与加载（.state_dict()、.load_state_dict()）。
与自动微分系统无缝集成。

主要组成部分
1. 初始化方法 init

调用 super().\__init__() 初始化父类。
在其中定义网络层（如 nn.Linear、nn.Conv2d）及其他子模块。
注册参数（通常通过子模块自动完成，也可手动使用 register_parameter）。

2. 前向传播方法 forward

定义输入数据如何通过网络层计算输出。
用户必须重写此方法。
调用模型实例（如 model(x)）时会自动调用 forward。

常用属性与方法
模型结构相关

.modules()：返回所有子模块的迭代器（包括自身）。
.children()：返回直接子模块的迭代器。
.named_modules() / .named_children()：返回带名称的模块迭代器。

参数管理

.parameters()：返回所有可学习参数（Parameter）的迭代器。
.named_parameters()：返回带名称的参数迭代器。
.register_parameter(name, param)：手动注册参数。

状态与设备

.state_dict()：返回包含所有参数和持久化缓冲区的字典。
.load_state_dict(state_dict)：从字典加载参数。
.to(device)：将模型及其参数移动到指定设备（CPU/GPU）。
.cpu() / .cuda()：快捷设备迁移方法。

模式切换

.train()：设置为训练模式（影响如 Dropout、BatchNorm 的行为）。
.eval()：设置为评估模式。
.training：布尔属性，表示当前模式。

其他实用方法

.zero_grad()：清空所有参数的梯度缓存。
.apply(fn)：对所有子模块递归应用函数（常用于初始化）。
.buffers() / .named_buffers()：访问非参数的持久化缓冲区（如 BatchNorm 的 running_mean）。
.register_buffer(name, tensor)：注册不参与优化但需保存的缓冲张量。

注意事项

所有在 __init__ 中定义的 nn.Module 子类实例会自动被注册为子模块。
直接赋值张量（非 Parameter 或 Module）不会被自动注册，需使用 register_buffer 或 register_parameter。
不应在 forward 中创建新的 nn.Module 实例，应提前在 __init__ 中定义。
模型可嵌套：一个 Module 可包含其他 Module，形成树状结构。

二、进阶

1.torch.nn.Linear类

torch.nn.Linear

torch.nn.Linear 是 PyTorch 中用于实现线性变换的类，即执行 y = xA^T + b 操作。
基本用法

torch.nn.Linear(in_features, out_features, bias=True, device=None, dtype=None)
参数说明

in_features (int)：输入样本的特征数（输入维度）。
out_features (int)：输出样本的特征数（输出维度）。
bias (bool, 可选)：如果为 True，则添加偏置项。默认值为 True。
device (torch.device, 可选)：权重和偏置所在的设备。
dtype (torch.dtype, 可选)：权重和偏置的数据类型。

属性

weight (torch.Tensor)：形状为 (out_features, in_features) 的可学习参数，表示权重矩阵。
bias (torch.Tensor)：形状为 (out_features,) 的可学习参数，表示偏置向量（如果 bias=True）。

方法

forward(input) -> torch.Tensor

执行前向传播。

参数：
    input (torch.Tensor)：形状为 (*, in_features) 的输入张量，其中 * 表示任意数量的额外维度。
返回值：
    torch.Tensor：形状为 (*, out_features) 的输出张量。

reset_parameters()

重置线性层的参数（权重和偏置）。

使用均匀分布初始化权重：U(-sqrt(k), sqrt(k))，其中 k = 1 / in_features。
偏置初始化为 0。

extra_repr() -> str

返回模块的额外字符串表示，用于 repr。

返回值：包含 in_features、out_features 和 bias 信息的字符串。

repr() -> str

返回该模块的字符串表示，例如：

Linear(in_features=10, out_features=5, bias=True)

state_dict(destination=None, prefix='', keep_vars=False)

返回包含模块状态（如 weight 和 bias）的字典。

load_state_dict(state_dict, strict=True)

从 state_dict 加载模块的状态。

parameters(recurse=True)

返回一个包含模块所有参数的迭代器。

named_parameters(prefix='', recurse=True)

返回一个包含模块所有参数名称和参数的迭代器。

buffers(recurse=True)

返回一个包含模块所有缓冲区的迭代器。

named_buffers(prefix='', recurse=True)

返回一个包含模块所有缓冲区名称和缓冲区的迭代器。

children()

返回一个包含直接子模块的迭代器（Linear 通常没有子模块）。

modules()

返回一个包含当前模块及其所有子模块的迭代器。

train(mode=True)

将模块设置为训练模式。

eval()

将模块设置为评估模式。

zero_grad(set_to_none=False)

将所有参数的梯度清零。

to(*args, **kwargs)

将模块移动到指定设备或转换为指定数据类型。

cuda(device=None)

将模块移动到 CUDA 设备。

cpu()

将模块移动到 CPU。

apply(fn)

对模块及其子模块递归应用函数 fn。

register_forward_hook(hook)

注册前向传播钩子。

register_forward_pre_hook(hook)

注册前向传播前钩子。

register_parameter(name, param)

注册一个新的参数。

register_buffer(name, tensor)

注册一个新的缓冲区。

add_module(name, module)

添加一个子模块。

type(dst_type)

将所有参数和缓冲区转换为 dst_type 类型。

float(), double(), half()

将模块转换为 float、double 或 half 类型。

示例

import torch
import torch.nn as nn
# 定义一个线性层
linear = nn.Linear(in_features=10, out_features=5)
# 输入张量
x = torch.randn(3, 10) # (batch_size, in_features)
# 前向传播
output = linear(x)
print(output.shape) # torch.Size([3, 5])

2.torch.optim.Optimizer类

torch.optim.Optimizer 是 PyTorch 中所有优化器的基类。用户通常不会直接实例化该类，而是使用其子类（如 SGD、Adam、AdamW 等）来更新模型参数。
基本用法

虽然 Optimizer 是一个抽象基类，不能直接实例化，但所有子类优化器的用法都遵循相同的模式。

构造方式（以子类为例）

optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
# 或
optimizer = torch.optim.Adam(model.parameters(), lr=0.001, betas=(0.9, 0.999))

3.torch.utils.data.Dataset & DataLoader类

torch.utils.data.Dataset & DataLoader

torch.utils.data.Dataset

Dataset 是一个抽象类，用于表示数据集。所有自定义数据集必须继承此类并实现必要方法。
核心方法

getitem(idx) -> Any

获取索引为 idx 的样本。

参数：
idx (int 或 slice)：样本索引。
返回值：单个样本数据（如图像、标签等）。
要求：必须实现。

len() -> int

返回数据集的总样本数。

返回值：数据集大小（int）。
要求：必须实现。

add(other: Dataset) -> ConcatDataset

支持使用 + 操作符将两个 Dataset 对象连接成一个 ConcatDataset。

特性

是所有数据集的基类。
提供与 Python 序列类似的接口。
可与 DataLoader 配合使用，实现高效数据加载。

torch.utils.data.DataLoader

DataLoader 用于加载 Dataset 中的数据，支持自动批处理、数据打乱、多进程数据加载 等功能。

构造函数

DataLoader(

dataset,

batch_size=1,

shuffle=False,

sampler=None,

batch_sampler=None,

num_workers=0,

collate_fn=None,

pin_memory=False,

drop_last=False,

timeout=0,

worker_init_fn=None,

multiprocessing_context=None,

generator=None,

prefetch_factor=2,

persistent_workers=False,

pin_memory_device=''

)

参数说明

dataset (Dataset)：要加载的数据集，必须是 Dataset 子类实例。

batch_size (int, 可选)：每个批次的样本数量。默认为 1。

shuffle (bool, 可选)：是否在每个 epoch 开始时打乱数据顺序。默认为 False。

sampler (Sampler, 可选)：定义从数据集中抽取样本的策略。若指定，则 shuffle 必须为 False。

batch_sampler (Sampler)：定义如何形成批次（每个元素是一个批次的索引列表）。与 batch_size、shuffle、sampler、drop_last 互斥。

num_workers (int, 可选)：用于数据加载的子进程数量。0 表示在主进程中加载。默认为 0。

collate_fn (callable, 可选)：合并样本列表为 mini-batch 的函数。用于处理不同大小的输入（如变长序列）。

pin_memory (bool, 可选)：若为 True，则将数据加载到带有 pinned memory 的 Tensor 中，可加快 CPU 到 GPU 的传输速度。默认为 False。

drop_last (bool, 可选)：若为 True，当最后一个批次样本数少于 batch_size 时丢弃。默认为 False。

timeout (int, 可选)：数据加载超时时间（秒）。默认为 0（无超时）。

worker_init_fn (callable, 可选)：每个 worker 初始化时调用的函数。

multiprocessing_context (multiprocessing.context, 可选)：用于多进程加载的上下文。

generator (torch.Generator, 可选)：用于可重现数据打乱的随机数生成器。

prefetch_factor (int, 可选)：每个 worker 预加载的批次数量。仅在 num_workers >

0 时有效。默认为 2。

persistent_workers (bool, 可选)：若为 True，则 DataLoader 在 epoch 之间保持 worker 进程存活。仅在 num_workers >

0 时有效。默认为 False。

pin_memory_device (str, 可选)：指定 pinned memory 的设备（如 'cuda'）。

核心功能

自动批处理数据。
支持单进程或多进程数据加载。
支持自定义数据加载顺序（通过 Sampler）。
支持内存锁定（pin_memory）以加速 GPU 训练。
支持预取（prefetching）以隐藏 I/O 延迟。

三、高级

1.torch.nn.Conv2d, torch.nn.MaxPool2d类

torch.nn.Conv2d 与 torch.nn.MaxPool2d 简介

torch.nn.Conv2d 和 torch.nn.MaxPool2d 是 PyTorch 中用于构建卷积神经网络（CNN）的核心模块，广泛应用于图像分类、目标检测、语义分割等计算机视觉任务中。它们分别实现二维卷积操作和二维最大池化操作，是深度神经网络中提取空间特征和降低特征图尺寸的关键组件。

torch.nn.Conv2d

torch.nn.Conv2d 是 PyTorch 提供的二维卷积层类，用于对输入的二维数据（如图像或特征图）执行卷积运算。卷积操作通过滑动一个可学习的卷积核（或滤波器）在输入数据上，计算局部区域的加权和，从而提取图像中的边缘、纹理、形状等低级到高级的空间特征。

其基本构造函数为：Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)。主要参数包括：in_channels 表示输入数据的通道数（如RGB图像为3），out_channels 表示输出特征图的通道数，即卷积核的数量；kernel_size 定义卷积核的大小（如3×3或5×5）；stride 控制卷积核滑动的步长，影响输出特征图的尺寸；padding 在输入边缘填充零值，用于控制输出尺寸或保留边缘信息；dilation 实现空洞卷积，扩大感受野而不增加参数；groups 支持分组卷积（如深度可分离卷积）；bias 决定是否使用偏置项。

卷积层的输出尺寸可通过公式计算：H_out = (H_in + 2×padding - dilation×(kernel_size - 1) - 1) / stride + 1（高度方向，宽度同理）。该层通过反向传播自动学习卷积核权重，使网络能够自适应地提取对任务最有用的特征。

torch.nn.MaxPool2d

torch.nn.MaxPool2d 是二维最大池化层，用于对卷积层输出的特征图进行下采样（downsampling）。其核心作用是降低特征图的空间维度（高度和宽度），从而减少后续层的计算量和参数数量，控制过拟合，并增强模型对微小平移、旋转等局部变换的不变性。

其基本形式为：MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)。kernel_size 指定池化窗口的大小（如2×2），stride 为池化窗口的移动步长，默认与 kernel_size 相同；padding 可在输入边缘补零；ceil_mode 决定输出尺寸计算时是否向上取整。

最大池化的工作机制是：在每个池化窗口内，选取最大值作为输出。这种操作保留了特征图中最显著的激活值，即最强烈的响应特征，同时丢弃了较弱的细节信息。相比于平均池化，最大池化更倾向于保留纹理和轮廓等关键结构信息，因此在大多数CNN架构中更为常用。

协同作用

在典型的卷积神经网络中，Conv2d 和 MaxPool2d 通常交替出现。例如，一个常见的模式是：多个 Conv2d 层堆叠用于提取深层特征，后接一个 MaxPool2d 层进行降维。这种结构使得网络能够逐层扩大感受野，捕捉从局部到全局的语义信息，同时保持计算效率。例如，在经典的VGG或ResNet网络中，这种组合被反复使用以构建深层模型。

总之，torch.nn.Conv2d 和 torch.nn.MaxPool2d 是构建现代视觉模型的基石，理解其原理和参数配置对于设计和调试深度学习网络至关重要。

2.torchvision.models类

torchvision.models 简介

torchvision.models 是 PyTorch 的视觉库 torchvision 中的一个核心模块 ，专门用于提供预训练的深度卷积神经网络模型。这些模型在大型图像数据集（主要是 ImageNet）上预先训练完成 ，可以直接用于图像分类、目标检测、语义分割等计算机视觉任务，极大地降低了深度学习应用的门槛，促进了迁移学习的广泛应用。

预训练模型的种类

torchvision.models 模块包含了大量经典的和前沿的深度神经网络架构。常见的图像分类模型包括：AlexNet、VGG 系列（如 VGG16、VGG19）、GoogLeNet（Inception v1）、Inception v3、ResNet 系列（如 ResNet18、ResNet50、ResNet101）、ResNeXt、DenseNet、MobileNet 系列（轻量级模型，适合移动端）、ShuffleNet、EfficientNet、RegNet 等。除了分类模型，该模块还提供了用于目标检测（如 Faster R-CNN、SSD、RetinaNet）、语义分割（如 FCN、DeepLabV3）、关键点检测（如 Keypoint R-CNN）和视频分类（如 R3D、MC3、R2Plus1D）的预训练模型。这些模型覆盖了从早期经典结构到最新高效架构的广泛范围，满足不同场景和性能需求。

迁移学习的支持

torchvision.models 的最大优势在于对迁移学习的原生支持。用户可以通过简单的参数设置（如 pretrained=True）加载在 ImageNet 上训练好的模型权重。这些权重包含了丰富的通用图像特征提取能力。在实际应用中，用户可以冻结模型的前几层（特征提取器） ，仅训练最后的分类头以适应新的类别；或者对整个网络进行微调（fine-tuning），使其在新数据集上达到最佳性能。这种方式显著减少了训练时间和所需数据量，尤其适用于数据稀缺或计算资源有限的场景。

使用的便捷性

该模块的设计高度模块化和用户友好。所有模型都遵循统一的接口，可以通过简洁的函数调用实例化。例如，models.resnet50(pretrained=True) 即可加载预训练的 ResNet-50 模型。模型的结构清晰，便于修改（如替换最后的全连接层以适应新任务）。此外，torchvision.models 与 torch.nn.Module 完全兼容，可以无缝集成到任何 PyTorch 训练流程中。模型权重通过 torch.hub 自动下载并缓存，简化了部署过程。

应用场景

torchvision.models 广泛应用于学术研究和工业实践。在图像分类任务中，可以直接使用预训练模型进行推理或微调。在目标检测和分割任务中，这些模型常作为骨干网络（backbone）提取基础特征，其强大的特征表达能力直接影响下游任务的性能。此外，它们也常被用作基线模型，用于评估新算法的有效性。由于其高效性和可靠性，torchvision.models 已成为深度学习视觉项目开发的标准工具之一。

3.torch.nn.Sequential类

torch.nn.Sequential 简介

torch.nn.Sequential 是 PyTorch 中一个非常实用且常用的容器类（container module），用于按顺序封装多个神经网络层或其他模块，形成一个顺序执行的神经网络结构。它简化了模型的构建过程，特别适用于那些层与层之间是简单线性连接（即前一层的输出直接作为后一层的输入）的网络架构，无需复杂的分支或条件逻辑。

核心功能与作用

Sequential 的主要作用是将一系列 nn.Module 的子类实例（如 nn.Linear、nn.Conv2d、nn.ReLU 等）组织成一个有序的序列。当输入数据传递给 Sequential 容器时，它会自动按照添加的顺序，依次将数据传递给内部的每个模块，并将前一个模块的输出作为下一个模块的输入，最终返回整个序列的输出结果。这种设计极大地简化了前向传播（forward）函数的编写，开发者无需手动编写每一层之间的数据传递逻辑。

构造方式

Sequential 可以通过多种方式构造。最常见的是直接将多个模块作为参数传入其构造函数，例如：nn.Sequential(nn.Linear(784, 256), nn.ReLU(), nn.Linear(256, 10))。此外，也可以通过传入一个有序字典（OrderedDict）来创建 Sequential，这种方式的优势是每个模块可以拥有一个自定义的名称，便于后续访问和调试，例如：nn.Sequential(OrderedDict([('fc1', nn.Linear(784, 256)), ('relu', nn.ReLU()), ('fc2', nn.Linear(256, 10))]))。

灵活性与访问

尽管 Sequential 强调顺序执行，但它仍然保持了高度的灵活性。用户可以通过整数索引（如 model[0]）或名称（如果使用 OrderedDict 创建）来访问和修改容器内的任意子模块。这使得在需要时可以轻松地冻结某些层、替换特定层或检查中间层的参数。此外，Sequential 本身也是一个 nn.Module，因此它可以像普通层一样被添加到其他 Sequential 容器或更复杂的网络结构中，实现模块化设计。

使用场景与局限性

Sequential 非常适合构建全连接网络（MLP）、简单的卷积神经网络（CNN）或自编码器等结构规整的模型。它让代码更加简洁、易读和易维护。然而，它的主要局限性在于无法处理具有分支、跳跃连接（如 ResNet 中的残差连接）、循环或条件执行的复杂网络结构。对于这类网络，开发者需要继承 nn.Module 并手动实现 forward 方法，以精确控制数据流。

总结

总而言之，torch.nn.Sequential 是 PyTorch 中一个高效、简洁的工具，用于快速构建顺序连接的神经网络。它通过自动化前向传播过程，减少了样板代码，提高了开发效率。虽然它不适用于所有网络架构，但对于大量常见的、线性堆叠的模型来说，Sequential 是一个不可或缺的利器，是初学者入门和资深开发者快速原型设计的首选工具之一。

专家级

1.自定义nn.Module子类

自定义 nn.Module 子类

在 PyTorch 中，torch.nn.Module 是所有神经网络模块的基类。虽然 torch.nn.Sequential 可以方便地构建线性堆叠的网络，但当需要实现更复杂的网络结构（如包含分支、跳跃连接、自定义前向逻辑等）时，必须通过继承 nn.Module 创建自定义子类。这是构建灵活、高级神经网络模型的核心方法。

基本结构

自定义 nn.Module 子类需要遵循特定的结构。首先，定义一个类继承 torch.nn.Module。然后，在 _init _ 方法中初始化所有需要的网络层，并调用 super().init () 以确保父类正确初始化。最后，必须实现 forward 方法，定义输入数据如何通过网络层进行前向传播并生成输出。

初始化方法 (init)

在 init 方法中，用户可以声明和实例化各种 nn.Module 子类（如 nn.Linear、nn.Conv2d、nn.BatchNorm2d 等）或 nn.Parameter（可学习参数）。所有在 init 中定义的 nn.Module 实例会自动被注册为模型的子模块，并通过 parameters() 方法暴露其参数，以便优化器进行更新。此外，也可以在此方法中定义其他辅助组件，如激活函数、损失函数等。

前向传播方法 (forward)
forward 方法定义了数据在网络中的流动方式 。它接收输入张量作为参数，通过调用在 _init _ 中定义的层，执行一系列操作，并返回输出张量。forward 方法可以包含任意的 Python 控制流（如 if 条件判断、for 循环），这使得实现动态网络结构（如 RNN、注意力机制、残差连接）成为可能。PyTorch 的自动微分系统会自动跟踪 forward 中的所有操作，以计算梯度。

参数与缓冲区

除了通过 nn.Module 子类定义的层，用户还可以使用 self.register_buffer() 注册非学习参数（如 BatchNorm 的运行均值和方差），或使用 self.register_parameter() 手动注册可学习参数。这些参数和缓冲区会被自动管理。

优势与应用

自定义 nn.Module 子类提供了最大的灵活性，是实现 ResNet、Transformer、GAN、自定义损失函数等复杂模型的基础。它允许开发者精确控制网络的每一部分，是进行深度学习研究和开发高级应用的必备技能。

2.torch.autograd类

torch.autograd

torch.autograd 是 PyTorch 的自动微分引擎，是其核心功能之一，为深度学习模型的训练提供了自动计算梯度的能力。它基于反向传播算法，能够高效地计算任意标量输出相对于其输入（通常是模型参数）的梯度，从而支持优化器更新参数。autograd 的设计使得用户无需手动推导和实现复杂的梯度公式，极大地简化了神经网络的开发过程。

核心机制

autograd 的工作原理基于动态计算图（Dynamic Computation Graph）。每当对 requires_grad=True 的张量执行操作时，PyTorch 会自动构建一个有向无环图（DAG），记录所有操作的历史。图中的节点代表张量（如输入、参数、输出），边代表施加在张量上的运算。这种"定义即运行"（define-by-run）的特性意味着计算图是在前向传播过程中实时构建的，与静态图框架不同，这为调试和实现动态网络结构（如可变长度的 RNN）提供了极大的灵活性。

关键组件

requires_grad：张量的一个布尔属性。若设置为 True，则该张量的所有操作都会被跟踪以计算梯度。通常，模型的参数（nn.Parameter）会自动设置此标志。

grad：张量的一个属性，用于存储计算出的梯度。在调用 backward() 后，梯度会被累积到 grad 属性中。

grad_fn：记录创建该张量的操作的函数（如 AddBackward, MulBackward）。它是构建计算图的关键，反向传播时通过 grad_fn 链式调用计算梯度。

.backward()：Tensor 的方法。调用它会触发反向传播，从当前张量（通常是损失值）开始，沿着计算图自动计算所有 requires_grad=True 的张量的梯度，并将结果累积到各自的 .grad 属性中。

使用方式

在典型的训练循环中，autograd 的使用流程如下：首先，前向传播计算损失（一个标量张量）；然后，调用 loss.backward() 自动计算所有参数的梯度；接着，优化器（如 SGD）使用这些梯度更新参数；最后，在下一次迭代前调用 optimizer.zero_grad() 或 model.zero_grad() 将梯度清零，防止梯度累积。

高级功能

torch.no_grad()：上下文管理器，用于禁用梯度计算。在推理或评估模型时使用，可减少内存消耗并加快计算速度。

detach()：从计算图中分离张量，返回一个不跟踪梯度的新张量。

torch.autograd.grad()：函数式接口，用于计算梯度，支持对非叶子张量或多个输出求导。

优势

torch.autograd 的动态计算图、易用的 API 和高效的梯度计算使其成为研究和开发的理想工具，尤其适合需要复杂或动态网络结构的场景。

3.分布式训练相关类

分布式训练相关类

PyTorch 提供了 torch.distributed 包，用于支持大规模分布式训练，以加速深度学习模型的训练过程。它通过在多个进程、GPU 或机器之间并行化计算和数据，有效解决了单设备内存和算力瓶颈。其核心类和模块主要基于 torch.multiprocessing 和通信后端（如 NCCL、Gloo），实现高效的跨设备数据同步与通信。

torch.distributed.init_process_group

该函数是分布式训练的起点，用于初始化进程组。它配置通信后端（如 "nccl" 用于 GPU，"gloo" 用于 CPU）、世界大小（world_size，总进程数）、当前进程的秩（rank）以及主节点地址（init_method）。调用此函数后，所有进程形成一个协作组，可以进行集体通信操作。

torch.nn.parallel.DistributedDataParallel (DDP)

DistributedDataParallel 是 PyTorch 推荐的分布式训练包装器。它将一个 nn.Module 模型包装起来，在每个进程中复制一份，并自动处理梯度的同步。DDP 使用 All-Reduce 算法在反向传播过程中聚合各进程计算的梯度，确保所有副本的参数保持一致。相比旧的 DataParallel，DDP 支持多机多卡、性能更高、显存占用更优，且能更好地利用 GPU 并行性。

torch.utils.data.distributed.DistributedSampler

这是一个为 DataLoader 设计的采样器，用于在分布式训练中将数据集均匀分割给不同的进程。它确保每个进程在每个 epoch 中加载互不重叠的数据子集，防止数据冗余。训练时通常设置 shuffle=True，并通过 epoch 参数调用 sampler.set_epoch(epoch) 来保证每轮数据打乱方式不同，提升训练效果。

集体通信原语（Collective Operations）

torch.distributed 提供了一系列底层通信操作，包括：

dist.all_reduce(tensor)：对所有进程的张量执行归约操作（如求和），并将结果广播到所有进程。
dist.broadcast(tensor, src)：从指定源进程向所有其他进程广播张量。
dist.scatter/gather：将张量分散到或收集自多个进程。
dist.all_gather(tensor_list, tensor)：将所有进程的张量收集到一个列表中。
这些原语可用于实现自定义的分布式算法或优化数据同步逻辑。

torch.distributed.launch / torchrun

这是用于启动分布式训练脚本的命令行工具。torchrun（新推荐）可以自动管理多个进程，根据指定的节点数和每节点 GPU 数启动相应数量的训练进程，并正确分配 rank 和 local_rank 参数，简化了多卡训练的启动流程。

核心优势

这些类共同构成了 PyTorch 高效、灵活的分布式训练框架，支持数据并行（DDP）、模型并行和流水线并行等多种策略，广泛应用于大模型训练和工业级 AI 系统。

学习建议

实践为主

深度学习和 PyTorch 的学习离不开动手实践。在掌握每一个新概念（如 nn.Module、autograd、DataLoader）后，应立即编写代码进行验证。例如，尝试构建一个简单的线性回归或图像分类模型，完整走通数据加载、模型定义、训练循环和评估流程。通过小型项目（如 MNIST 分类、自定义神经网络）将理论知识转化为实际技能，能显著加深理解并发现潜在问题。

逐步深入

学习应遵循由浅入深的路径。建议从张量操作和自动微分开始，再过渡到 nn.Module 和优化器，最后学习分布式训练和高级功能。确保对基础概念（如 requires_grad、backward()、forward 流程）有扎实掌握后再进入复杂主题（如自定义反向传播、混合精度训练）。跳跃式学习容易导致知识断层，影响长期发展。

查阅官方文档

PyTorch 官方文档（pytorch.org）是权威且全面的学习资源。每个类（如 torch.nn.Linear、torch.optim.Adam）都有详细的参数说明、方法列表和使用示例。建议养成遇到问题先查阅文档的习惯，不仅能准确理解 API 用法，还能发现新功能和最佳实践。此外，PyTorch 教程（Tutorials）提供了从入门到高级的实战案例，极具参考价值。

结合社区与项目

积极参与 PyTorch 论坛、GitHub 和 Stack Overflow，阅读他人代码，提出问题并分享经验。尝试复现经典论文的代码或参与开源项目，能快速提升实战能力。通过遵循上述学习路径，并持续进行编程练习，你将系统地掌握 PyTorch 的核心类与概念，逐步建立起构建和训练复杂模型的信心与能力。