PyTorch 卷积与自动微分引擎深入解析:NYU-DLSP20 第 5 周实践课导读

原创2026-10-09 12:24:122,227 阅读
文章标签:示例工程

PyTorch 卷积与自动微分引擎深入解析:NYU-DLSP20 第 5 周实践课导读

本篇技术指南以 NYU-DLSP20(NYU Deep Learning Spring 2020)第 5 周实践课笔记 docs/tr/week05/05-3.md(对应英文原版 docs/en/week05/05-3.md)为主体,系统讲解卷积的数学直觉、PyTorch 中 nn.Conv1d / nn.Conv2d 的核维度与输出宽度推导,以及 torch.autograd 自动微分引擎的原理与自定义梯度模块的写法。读完本文,你将能够独立推导卷积输出尺寸、理解 requires_grad 与 no_grad 的梯度累积语义,并动手编写继承 torch.autograd.Function 的自定义可微模块。

一、从矩阵乘法到卷积:稀疏性、平稳性与组合性

在理解 1D 卷积之前,先回顾第 4 周笔记 docs/tr/week04/04-1.md 中介绍的线性代数观点:一个隐藏层可表示为 z=Ax\boldsymbol{z} = \boldsymbol{A}\boldsymbol{x},其中 A∈Rm×n\boldsymbol{A} \in \mathbb{R}^{m\times n} 是仿射变换矩阵。全连接矩阵的问题是:每个输出都需要所有输入参与,参数稠密、且对输入的平移不具备不变性。

卷积的关键思想是把矩阵宽度替换为核大小 kk:矩阵的每一行就是一个核(kernel),通过**堆叠(stacking)与滑动(shifting)**这些核来扫描输入。这样得到 mm 层、每层高度为 n−k+1n-k+1 的特征输出。

一维卷积示意图:输入长度为 n,核大小为 k,通过堆叠与滑动得到长度 n-k+1 的输出

这种结构直接带来了学习数据的三种性质所需的归纳偏置:

  • 稀疏性(sparsity):每个输出只与长度为 kk 的局部输入窗口相关,权重是稀疏连接的;
  • 平稳性(stationarity):同一个核在序列所有位置共享权重,即权值共享,对平移具有等变性;
  • 组合性(compositionality):低层特征可以堆叠成高层语义,通过多层卷积逐级组合。

卷积的输出是 mm 个(厚度)长度为 n−k+1n-k+1 的向量,即输出张量形状为 m×(n−k+1)m \times (n-k+1)。

把输入看作信号映射

一个单输入向量可以被视为单声道(monophonic)信号。更一般地,输入 xx 是一个映射:

x:Ω→Rcx:\Omega\rightarrow\mathbb{R}^{c}

其中 Ω={1,2,3,⋯ }⊂N1\Omega = \lbrace 1, 2, 3, \cdots \rbrace \subset \mathbb{N}^1(因为这是 1 维信号,定义域是 1 维的),此时通道数 c=1c=1;当 c=2c=2 时,就变成立体声(stereophonic)信号。

对于 1D 卷积,计算过程就是逐核做标量乘积(scalar product):核在输入上每滑动一个位置,就与对应的局部窗口做逐元素相乘后求和,得到一个输出标量。重复该过程直到核扫过整个序列,便得到完整输出特征图。

二、PyTorch 中核的维度与输出宽度

在 IPython 中,可以用 问号(?) 快速查看函数文档。nn.Conv1d 的完整初始化签名为:

Init signature:
nn.Conv1d(
	in_channels,           # number of channels in the input image
	out_channels,          # number of channels produced by the convolution
	kernel_size,           # size of the convolving kernel
	stride=1,              # stride of the convolution
	padding=0,             # zero-padding added to both sides of the input
	dilation=1,            # spacing between kernel elements
	groups=1,              # nb of blocked connections from input to output
	bias=True,             # if `True`, adds a learnable bias to the output
	padding_mode='zeros',  # accepted values `zeros` and `circular`
)

各参数含义与默认值如下:

参数 默认值 说明
in_channels 必填 输入通道数
out_channels 必填 卷积产生的输出通道数(即核的个数)
kernel_size 必填 卷积核大小
stride 1 卷积滑动步长
padding 0 输入两侧补零的层数
dilation 1 核元素之间的间隔(空洞卷积)
groups 1 输入到输出的分组连接数
bias True 是否为输出添加可学习的偏置
padding_mode 'zeros' 填充方式,可取 zeros 或 circular

1D 卷积示例

构建一个从 22 通道(立体声信号)到 1616 通道(1616 个核)的 1D 卷积,核大小为 33、步长为 11。此时我们拥有 1616 个厚度为 22、长度为 33 的核。假设输入信号 batch 大小为 11、通道数 22、采样数 6464,则输出层为 11 个信号、1616 个通道、信号长度为 6262(=64−3+1=64-3+1)。偏置大小为 1616,因为每个输出通道对应一个偏置:

conv = nn.Conv1d(2, 16, 3)  # 2 channels (stereo signal), 16 kernels of size 3
conv.weight.size()          # output: torch.Size([16, 2, 3])
conv.bias.size()            # output: torch.Size([16])

x = torch.rand(1, 2, 64)    # batch of size 1, 2 channels, 64 samples
conv(x).size()              # output: torch.Size([1, 16, 62])

conv = nn.Conv1d(2, 16, 5)  # 2 channels, 16 kernels of size 5
conv(x).size()              # output: torch.Size([1, 16, 60])

注意核大小从 33 增大到 55 后,输出长度从 6262 变为 6060(=64−5+1=64-5+1),即输出长度随 kernel_size 增大而线性缩短,这正是无 padding 卷积的尺寸规律。

2D 卷积示例

将输入数据定义为 11 个样本、2020 个通道(例如高光谱图像)、高 6464、宽 128128。2D 卷积取输入的 2020 个通道,配 1616 个 3×53\times5 的核。卷积后输出为 11 个样本、1616 个通道,高 6262(=64−3+1=64-3+1)、宽 124124(=128−5+1=128-5+1):

x = torch.rand(1, 20, 64, 128)    # 1 sample, 20 channels, height 64, and width 128
conv = nn.Conv2d(20, 16, (3, 5))  # 20 channels, 16 kernels, kernel size is 3 x 5
conv.weight.size()                # output: torch.Size([16, 20, 3, 5])
conv(x).size()                    # output: torch.Size([1, 16, 62, 124])

从权重形状 [16, 20, 3, 5] 可以看出,2D 卷积存储整组核需要 44 个维度:输出通道数、输入通道数、核高、核宽。

用 padding 保持输出尺寸

若希望输出与输入尺寸一致,可以补 padding。在上例基础上设置 stride=1、padding=(1, 2),即在 yy 方向上下各补 11 行、在 xx 方向左右各补 22 列。此时输出信号与输入信号尺寸相同:

# 20 channels, 16 kernels of size 3 x 5, stride is 1, padding of 1 and 2
conv = nn.Conv2d(20, 16, (3, 5), 1, (1, 2))
conv(x).size()  # output: torch.Size([1, 16, 64, 128])

这里的尺寸关系可统一表述为:输出尺寸 =⌊(输入尺寸+2×padding−kernel)/stride⌋+1= \lfloor (\text{输入尺寸} + 2\times\text{padding} - \text{kernel}) / \text{stride} \rfloor + 1。当 stride=1 且 padding = (kernel-1)/2 时(本例 yy 方向 (3−1)/2=1(3-1)/2=1,xx 方向 (5−1)/2=2(5-1)/2=2),输出与输入保持同尺寸。

三、自动梯度引擎如何工作

要让 Torch 跟踪张量上的全部计算以便求偏导,需要开启梯度累积能力。以文档中的经典示例演示完整链路:

  1. 创建 2×22\times2 的 x\boldsymbol{x} 张量,并开启梯度累积;
  2. 从 x\boldsymbol{x} 的所有元素中减去 22,得到 y\boldsymbol{y}(打印 y.grad_fn 会得到类似 <SubBackward0 object>,说明 y\boldsymbol{y} 由减法模块 x−2\boldsymbol{x}-2 生成;也可通过 y.grad_fn.next_functions[0][0].variable 回溯到原始张量);
  3. 继续运算 z=3y2\boldsymbol{z} = 3\boldsymbol{y}^2;
  4. 计算 z\boldsymbol{z} 的均值 aa。

自动梯度示例的流程图:从输入 x 经 SubBackward0、MulBackward0 到 MeanBackward0 的反向传播路径

反向传播用于计算梯度,本例中即为 dadx\frac{d\boldsymbol{a}}{d\boldsymbol{x}}。先手工推导作为验证:

a=14(z1+z2+z3+z4)zi=3yi2=3(xi−2)2dadxi=14×3×2(xi−2)=32xi−3x=(1234)(dadxi)⊤=(1.5−33−34.5−36−3)=(−1.501.53)\begin{aligned} a &= \frac{1}{4} (z_1 + z_2 + z_3 + z_4) \\ z_i &= 3y_i^2 = 3(x_i-2)^2 \\ \frac{da}{dx_i} &= \frac{1}{4}\times3\times2(x_i-2) = \frac{3}{2}x_i-3 \\ x &= \begin{pmatrix} 1&2\\3&4\end{pmatrix} \\ \left(\frac{da}{dx_i}\right)^\top &= \begin{pmatrix} 1.5-3&3-3\\[2mm]4.5-3&6-3\end{pmatrix}=\begin{pmatrix} -1.5&0\\[2mm]1.5&3\end{pmatrix} \end{aligned}

执行 a.backward() 后得到的 x.grad 与上述手工计算结果完全一致。需要强调一个易错点:在 PyTorch 中使用偏导数时,得到的梯度张量与原始数据形状相同,但数学上真正的 Jacobian 矩阵是该结果的转置。PyTorch 约定 x.grad 与 x 同形状,而实际 Jacobian 是 x.grad 的转置。

四、从基础到进阶:利用梯度推断迭代次数

文档接着演示了一个更有趣的场景:设 xx 为 1×31\times3 向量,令 y=2xy=2x,然后不断将 yy 翻倍,直到其范数小于 10001000。由于 xx 是随机初始化的,无法直接预知循环次数:

x = torch.randn(3, requires_grad=True)

y = x * 2
i = 0
while y.data.norm() < 1000:
    y = y * 2
    i += 1

但我们能利用已经掌握的梯度轻松反推迭代次数。由于 yy 对 xx 的梯度恰为 2(i+1)2^{(i+1)}(每次翻倍乘 22,加上初始的 ×2\times2),传入任意梯度种子即可验证:

gradients = torch.FloatTensor([0.1, 1.0, 0.0001])
y.backward(gradients)

print(x.grad)
tensor([1.0240e+02, 1.0240e+03, 1.0240e-01])
print(i)
9

x.gradx.grad 的三个值正是初始种子分别乘以 210=10242^{10}=1024 的结果(0.1×1024=102.40.1\times1024=102.4、1.0×1024=1024.01.0\times1024=1024.0、0.0001×1024=0.10240.0001\times1024=0.1024),由此反推循环执行了 99 次翻倍。这个例子生动说明了非标量输出反向传播时 grad_output(梯度种子)的用法。

requires_grad 与 no_grad:梯度累积的控制

用 requires_grad=True 标记希望追踪梯度累积的张量。若在 xx 或 ww 声明中省略 requires_grad=True 却对 zz 调用 backward(),会因为 xx 或 ww 上没有梯度累积而抛出运行时错误:

# Gradyan birikmesine izin veren x ve w(允许梯度累积的 x 与 w)
x = torch.arange(1., n + 1, requires_grad=True)
w = torch.ones(n, requires_grad=True)
z = w @ x
z.backward()
print(x.grad, w.grad, sep='\n')

反过来,可以用 with torch.no_grad(): 显式关闭梯度累积:

x = torch.arange(1., n + 1)
w = torch.ones(n, requires_grad=True)

# Tüm Torch tensörlerinde gradyan birikimi olmayacaktır(所有 Torch 张量都不会累积梯度)
with torch.no_grad():
    z = w @ x

try:
    z.backward()  # z 没有梯度累积,PyTorch 在这里抛错
except RuntimeError as e:
    print('RuntimeError!!! >:[')
    print(e)

no_grad 上下文在推理阶段非常实用:它可以避免构建计算图、节省显存并加速前向过程。在仓库中,torch.no_grad() 的这种用法还在 03-autograd_tutorial.ipynb 中有配套实验,读者可结合该 notebook 进一步验证。

五、自定义梯度:扩展 torch.autograd.Function

除了内建数值运算,还可以把自定义模块/函数接入神经网络计算图。实现方法是:继承 torch.autograd.Function,并覆写 forward() 与 backward()。只要知道输入对输出的偏导,就可以借助反向传播(链式法则)把该模块插入运算链的任意位置。配套的完整代码见仓库中的 extra/b-custom_grads.ipynb,该 notebook 中实现了 add、split、max 三个自定义模块。

自定义加法模块

文档给出的加法模块使用 ctx(上下文对象)在 forward 中保存中间张量供 backward 使用:

# Custom addition module(自定义加法模块)
class MyAdd(torch.autograd.Function):

    @staticmethod
    def forward(ctx, x1, x2):
        # ctx is a context where we can save
        # computations for backward.
        ctx.save_for_backward(x1, x2)
        return x1 + x2

    @staticmethod
    def backward(ctx, grad_output):
        x1, x2 = ctx.saved_tensors
        grad_x1 = grad_output * torch.ones_like(x1)
        grad_x2 = grad_output * torch.ones_like(x2)
        # need to return grads in order
        # of inputs to forward (excluding ctx)
        return grad_x1, grad_x2

对两个输入做加法得到一个输出时,forward 按此覆写;反向传播时梯度被复制到两侧(加法对每个输入的偏导均为单位张量),因此 backward 通过 ones_like 复制梯度并按 forward 输入顺序(排除 ctx)返回。

notebook 中的更多实现

extra/b-custom_grads.ipynb 还给出了三个进阶实现,可作为源码级佐证:

  • AddAndAverage(加和求平均):forward 返回 (x1+x2)(x_1+x_2) 的均值,backward 中梯度按 x.numel() 归一化,即 grad_x = grad_output * torch.ones_like(x) / x.numel(),体现 ctx.save_for_backward 与 ctx.saved_tensors 的配合使用;
  • MySplit(分裂):forward 将同一输入克隆成两个输出并保存;backward 接收两份梯度,**必须相加(grad_x1 + grad_x2)**后返回——因为同一个张量被两个分支消费时,其梯度等于各分支梯度之和;
  • MyMax(取最大):forward 用 x.detach().numpy().max() 求最大值,并用 x.detach().eq(maximum).float() 构造 one-hot 的 argmax 掩码存入 ctx;backward 返回 grad_output * argmax——即只有取到最大值的那个位置获得梯度(索引为 1),其余位置梯度为 0。这恰好演示了如何使用非 Torch 代码(NumPy)参与前向,同时保持整体可微。

可见,不同自定义模块需要覆写各自的前向过程,并在 backward 中按各自的导数语义计算梯度。上述 add、split、max 正是构建更复杂自定义算子(如 Gumbel-Softmax、Straight-Through Estimator 等)的基本范式。

六、延伸与实践建议

本节内容属于第 5 周实践课(Practicum)的一部分,整体脉络可参考 docs/tr/week05/05.md:先回顾矩阵乘法,再讨论卷积,最后落到自动梯度与自定义梯度。想动手验证本文的代码,可结合以下仓库资源:

实践检查清单:

  1. 用 nn.Conv1d(2, 16, 3) 与 nn.Conv1d(2, 16, 5) 分别观察输出长度变化,验证 n−k+1n-k+1;
  2. 用 nn.Conv2d(20, 16, (3, 5), 1, (1, 2)) 验证 padding 保持空间尺寸;
  3. 在 x 未设 requires_grad=True 时调用 backward(),观察 RuntimeError 的抛出时机;
  4. 修改 MyMax 的输入,确认只有最大值位置的梯度非零;
  5. 将 MySplit 的输出分别乘以不同系数再求和反向,验证分裂节点梯度相加规则。

通过对卷积尺寸的定量推导和 autograd 引擎的逐层拆解,你将具备把任意自定义可微算子无缝接入 PyTorch 训练链路的能力——这正是从"使用框架"迈向"理解框架"的关键一步。

登录后查看全文
NYU-DLSP20