NYU DLSP20 第 5 周实操:用 PyTorch 理解一维/二维卷积与自动微分引擎

原创2026-10-10 23:31:571,747 阅读
文章标签:示例工程

NYU DLSP20 第 5 周实操:用 PyTorch 理解一维/二维卷积与自动微分引擎

本文是 NYU Deep Learning Spring 2020(NYU-DLSP20,仓库名 pytorch-Deep-Learning)第 5 周实践课(docs/it/week05/05-3.md,与英文版 docs/en/week05/05-3.md 对应)的中文技术导读。课程讲师为 Alfredo Canziani。本篇围绕两个核心主题展开:如何用"堆叠 + 平移"(stacking & shifting)的视角理解一维、二维卷积,并精确推算出 PyTorch 中 nn.Conv1d / nn.Conv2d 的输出尺寸;以及如何借助 requires_grad、backward()、grad_fn、torch.no_grad() 和自定义 torch.autograd.Function 掌控 PyTorch 的自动微分引擎。读完本文,你将能够手算任意卷积层的输出宽高、手动验证反向传播得到的梯度,并写出可插入计算图的自定义可微模块。

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

在 第 4 周实践课(线性代数与卷积)中,输入通过全连接矩阵 A∈Rm×n\boldsymbol{A} \in \mathbb{R}^{m\times n} 与向量 x\boldsymbol{x} 相乘得到输出。本周我们要探索自然数据的三个性质——稀疏性(sparsity)、平稳性(stationarity)与组合性(compositionality)——正是这些性质催生了卷积运算。

关键转变在于:不再使用宽度为 nn 的稠密矩阵 A\boldsymbol{A},而是把矩阵宽度改成卷积核尺寸 kk。这样一来,矩阵的每一行都可以被解释为一个独立的 kernel(卷积核)。通过"堆叠(stacking)"多个 kernel 获得厚度(通道数),通过"平移(shifting)"让同一个 kernel 在输入序列的不同位置上滑动,就构成了卷积层。

一维卷积示意图:通过堆叠与平移使用多个卷积核

若输入长度为 nn、kernel 尺寸为 kk,则每个 kernel 在每个位置上做一次局部运算,输出长度为:

n−k+1n - k + 1

堆叠 mm 个 kernel 后,卷积层的输出就是 mm 个(厚度方向)长度为 n−k+1n-k+1 的向量(见下图)。

一维卷积的输出:m 个长度为 n-k+1 的向量

一个朴素的输入向量可以被看作单声道(monophonic)信号:每个时间点只有 1 个数值。

单声道信号示意

1.1 输入的形式化定义:从标量序列到通道映射

把输入 x\boldsymbol{x} 正式写成映射:

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

其中 Ω={1,2,3,⋯ }⊂N1\Omega = \lbrace 1, 2, 3, \cdots \rbrace \subset \mathbb{N}^1。因为这是一维信号,定义域是 1 维的;cc 是通道数。当 c=1c=1 时是单声道信号,当 c=2c=2 时就是立体声(stereophonic)信号——这正是后面 nn.Conv1d(2, 16, 3) 示例中"2 通道"的来源。

1.2 一维卷积 = kernel 逐层标量积

对于一维卷积,我们只需要逐 kernel 地计算标量积(scalar product):把 kernel 与输入上对应位置的窗口做内积,然后平移窗口重复操作。

一维卷积的逐层标量积

这种"参数共享 + 局部连接"的结构正是卷积层能大幅减少参数量、同时保持平移等变性的根本原因。

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

2.1 快速查阅文档的小技巧:IPython 问号

在 IPython/Jupyter 中,在函数名后加一个 问号 ? 即可弹出该函数的文档签名。以 nn.Conv1d 为例:

Init signature:
nn.Conv1d(
    in_channels,           # 输入图像/信号的通道数
    out_channels,          # 卷积产生的输出通道数
    kernel_size,           # 卷积核尺寸
    stride=1,              # 卷积步长
    padding=0,             # 在输入两侧补零的数量
    dilation=1,            # 卷积核元素之间的间距(空洞卷积)
    groups=1,              # 输入到输出之间的分组连接数
    bias=True,             # 若为 True,则给输出添加一个可学习的偏置
    padding_mode='zeros',  # 可取值 'zeros' 与 'circular'
)

这正是本仓库实践课配套的 03-autograd_tutorial.ipynb 与 b-custom_grads.ipynb 所依赖的核心参数体系。

2.2 一维卷积实例:立体声信号 → 16 通道

设一维卷积将 2 通道(立体声信号)变为 16 通道(16 个 kernel),kernel 尺寸为 3、步长为 1。于是我们有 16 个厚度为 2、长度为 3 的 kernel(厚度等于输入通道数)。

输入信号假设为:batch 大小 1(一个信号)、2 通道、64 个采样点。则输出层为:1 个信号、16 通道,信号长度:

64−3+1=6264 - 3 + 1 = 62

偏置的个数与输出通道数一致——每个输出通道(每个 kernel)对应一个 bias,因此 conv.bias.size() 为 torch.Size([16])。

conv = nn.Conv1d(2, 16, 3)  # 2 通道(立体声),16 个尺寸为 3 的 kernel
conv.weight.size()          # 输出: torch.Size([16, 2, 3])
conv.bias.size()            # 输出: torch.Size([16])

x = torch.rand(1, 2, 64)    # batch 大小 1,2 通道,64 个采样点
conv(x).size()              # 输出: torch.Size([1, 16, 62])

conv = nn.Conv1d(2, 16, 5)  # 2 通道,16 个尺寸为 5 的 kernel
conv(x).size()              # 输出: torch.Size([1, 16, 60])   (64-5+1=60)

规律清晰可见:kernel 尺寸每增大 1,输出长度就缩短 1;weight 的形状永远是 [out_channels, in_channels, kernel_size]。

2.3 二维卷积实例:高光谱图像

现在考虑输入为 1 张图像,包含 20 个通道(可想象成高光谱图像,hyperspectral image),高度 64、宽度 128。二维卷积取 20 个输入通道、16 个尺寸为 3×53\times5 的 kernel。

卷积后输出仍是 1 张图像、16 个通道,高度和宽度分别变为:

高度=64−3+1=62,宽度=128−5+1=124\text{高度} = 64 - 3 + 1 = 62,\qquad \text{宽度} = 128 - 5 + 1 = 124

x = torch.rand(1, 20, 64, 128)    # 1 个样本,20 通道,高 64,宽 128
conv = nn.Conv2d(20, 16, (3, 5))  # 20 通道,16 个 kernel,kernel 尺寸 3 x 5
conv.weight.size()                # 输出: torch.Size([16, 20, 3, 5])
conv(x).size()                    # 输出: torch.Size([1, 16, 62, 124])

注意 2D 卷积下 weight 是 4 维张量 [out_channels, in_channels, k_h, k_w]——文档里明确强调"执行 2D 卷积时,存储整组 kernel 需要 4 个维度"。

2.4 用 padding 保持空间维度不变

若希望输出与输入保持相同的空间尺寸,就需要引入 padding。沿用上面的代码,在卷积函数中追加参数 stride=1 与 padding=(1, 2),其含义是:在 yy(高度)方向各补 1 像素(图像上方 1 个、下方 1 个),在 xx(宽度)方向各补 2 像素。此时输出与输入尺寸一致:

# 20 通道,16 个尺寸为 3 x 5 的 kernel,stride 为 1,padding 为 (1, 2)
conv = nn.Conv2d(20, 16, (3, 5), 1, (1, 2))
conv(x).size()  # 输出: torch.Size([1, 16, 64, 128])

这里蕴含的通用公式是:补零后输出尺寸 =输入尺寸−k+1+2×padding= \text{输入尺寸} - k + 1 + 2 \times \text{padding}。当 kernel 为 3 时,padding=1 即可"保尺寸";当 kernel 宽为 5 时,则需 padding=2。这也是后面 06-convnet.ipynb 中 CNN 网络反复使用的保尺寸技巧。

三、自动梯度(autograd)是如何工作的?

这一节我们让 PyTorch 追踪张量上的全部运算,从而自动完成偏导数的计算。配套的 03-autograd_tutorial.ipynb 完整演示了整个过程。

3.1 一个完整的追踪-反向传播示例

步骤如下:

  1. 创建 2×22\times2 的张量 x\boldsymbol{x},开启梯度累积能力(requires_grad=True);
  2. 让所有元素减去 2,得到 y\boldsymbol{y};
  3. 继续运算:z=3y2\boldsymbol{z} = 3\boldsymbol{y}^2;
  4. 对 z\boldsymbol{z} 求平均得到标量 aa。
# 创建 2x2 张量,开启梯度追踪
x = torch.tensor([[1, 2], [3, 4]], requires_grad=True, dtype=torch.float32)

# 所有元素减去 2
y = x - 2

# 打印 y.grad_fn,得到 <SubBackward0 object at 0x...>
# 说明 y 是由减法模块 (x-2) 生成的
print(y.grad_fn)

# 还可以通过 y.grad_fn.next_functions[0][0].variable 找回原始张量 x
print(y.grad_fn.next_functions[0][0].variable)

# 继续运算
z = y * y * 3      # 等价于 3y^2
a = z.mean()       # 求平均

自动梯度示例的流程图(计算图)

这里 y.grad_fn 的类型 SubBackward0 揭示了 autograd 的核心机制:每个由运算产生的张量都挂着一个 grad_fn,记录"它是通过什么运算、由哪些张量生成的"。grad_fn.next_functions 指向它的输入节点,从而把整个运算链串成一幅动态计算图——这正是 autograd "define-by-run"(随运行定义)框架的本质:反向传播由代码实际执行路径决定,每次迭代都可以不同。

3.2 手工验证反向传播结果

反向传播(backpropagation)就是用来计算梯度的。在本例中,反向传播过程可以看作计算 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 会与上述手工计算完全一致:

a.backward()
print(x.grad)
# tensor([[-1.5000,  0.0000],
#         [ 1.5000,  3.0000]])

值得强调一个容易混淆的细节:在 PyTorch 中求偏导时,得到的梯度形状与原始数据形状相同;而数学上正确的 Jacobian 应当是它的转置。也就是说,PyTorch 的 x.grad 存放的是 ∂a∂xi\dfrac{\partial a}{\partial x_i} 的逐元素值,与 (dadxi)⊤\left(\dfrac{da}{dx_i}\right)^\top 的布局对应关系需要结合具体求导语境理解。

3.3 从基础走向"疯狂":动态图中的循环求导

现在我们有一个 1×31\times3 的向量 xx,令 yy 为 xx 的两倍,然后不断把 yy 翻倍,直到其范数小于 1000:

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

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

由于 xx 是随机生成的,我们无法预知循环会执行多少次。但借助梯度可以轻松推断出迭代次数。因为 yy 是标量倍数关系,反向传播时我们需要为 backward() 指定一个与 yy 同形状的梯度种子(grad_output):

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

关键点:当 backward() 的目标不是标量时,必须显式传入 grad_output——正如 notebook 中注释所言 "If we don't run backward on a scalar we need to specify the grad_output"。同时这个例子体现了 autograd 对**动态控制流(循环)**的原生支持:循环展开多少次,计算图就记录多少次,梯度依然精确。

3.4 推理(Inference)场景:requires_grad 与 torch.no_grad()

推理时我们不再需要梯度。可以在声明张量时用 requires_grad=True 明确"我想要追踪梯度累积";反之,如果省略该参数,梯度就不会累积。示例:xx 与 ww 都允许梯度累积时:

# x 与 w 都允许梯度累积
n = 3
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')
# x.grad: tensor([1., 1., 1.])
# w.grad: tensor([1., 2., 3.])

可以手动验证:z=∑iwixiz = \sum_i w_i x_i,故 ∂z/∂xi=wi=1\partial z/\partial x_i = w_i = 1,∂z/∂wi=xi=i\partial z/\partial w_i = x_i = i。

如果 xx 或 ww 声明时省略了 requires_grad=True,再对 zz 调用 backward() 就会因为缺少梯度累积而抛出运行时错误。同理,我们还可以用 with torch.no_grad(): 上下文管理器,在推理阶段显式关闭梯度累积,既能省内存又能提速:

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

# 在这个上下文内,所有张量都不会累积梯度
with torch.no_grad():
    z = w @ x

try:
    z.backward()  # PyTorch 将在此报错,因为 z 没有梯度累积
except RuntimeError as e:
    print('RuntimeError!!! >:[')
    print(e)

这段代码来自仓库 03-autograd_tutorial.ipynb 的 "Inference" 一节,是训练/推理模式下控制梯度行为的标准范式。

四、进阶:自定义梯度(Custom Gradients)

除了内置的基本数值运算,我们还可以编写自定义的可微模块/函数,并将其插入神经网络的计算图。完整代码见仓库中的 extra/b-custom_grads.ipynb。

4.1 自定义可微模块的三步法

要做这件事,需要继承 torch.autograd.Function,并重写 forward() 与 backward() 两个静态方法:

  • forward(ctx, *args):执行前向运算。第一个参数必须是上下文 ctx,可用 ctx.save_for_backward(...) 保存中间张量供反向使用;
  • backward(ctx, *grad_outputs):定义该运算的求导公式。它接收"关于每个输出的梯度",并返回"关于每个输入的梯度",返回顺序必须与前向输入的参数顺序一致(且排除 ctx)。

这正是训练神经网络所需的全部要素:前向求出输出,反向知道输出对输入的偏导,然后借助链式法则(backpropagation),这个模块就可以被安插在运算链的任意位置——只要我们能写出"输出对输入的偏导"。

4.2 三个经典示例:add、split、max

notebook 中给出了三个自定义模块示例:add(加法)、split(分裂)、max(取最大)。

(1)加法模块 MyAdd

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

    @staticmethod
    def forward(ctx, x1, x2):
        # ctx 是一个上下文,我们可以在其中保存
        # 供 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)
        # 需要按 forward 输入的参数顺序返回梯度(排除 ctx)
        return grad_x1, grad_x2

加法把两个对象合并为一个输出:前向直接相加;反向时梯度需要同时复制到两个输入上(y=x1+x2y=x_1+x_2 对两个输入的偏导都是 1,所以梯度原样通过)。调用方式为 MyAdd.apply(x1, x2)。

(2)分裂模块 MySplit

# 自定义分裂模块
class MySplit(torch.autograd.Function):
    @staticmethod
    def forward(ctx, x):
        ctx.save_for_backward(x)
        x1 = x.clone()
        x2 = x.clone()
        return x1, x2

    @staticmethod
    def backward(ctx, grad_x1, grad_x2):
        x = ctx.saved_tensors[0]
        print(f'grad_x1: {grad_x1}')
        print(f'grad_x2: {grad_x2}')
        return grad_x1 + grad_x2

分裂模块的语义是"从一个张量分出两个副本"。由于前向产生两个输出,反向就会收到两个梯度(分别对应两个输出);而这两个梯度都源自同一个输入 xx,所以反向时应当把两个梯度相加(xx 对最终损失的贡献是两条路径之和)。notebook 中用 y = 1 * x1 + 2 * x2 的示例验证了这一点。

(3)最大值模块 MyMax

# 自定义 max 模块
class MyMax(torch.autograd.Function):
    @staticmethod
    def forward(ctx, x):
        # 示例:显式使用非 torch 代码
        maximum = x.detach().numpy().max()
        argmax = x.detach().eq(maximum).float()
        ctx.save_for_backward(argmax)
        return torch.tensor(maximum)

    @staticmethod
    def backward(ctx, grad_output):
        argmax = ctx.saved_tensors[0]
        return grad_output * argmax

max 选取最大值元素的下标(argmax):前向时用 argmax 构造一个 one-hot 掩码(最大值位置为 1,其余为 0)并保存在 ctx 中;反向时把梯度只"发放"给取到最大值的那个位置——该位置梯度为 1,其余位置为 0(严格说是 grad_output * argmax)。

注意 MyMax.forward 里使用了 x.detach():这是为了让张量脱离计算图、转成 numpy 做非可微运算(找最大值),因为"取最大值"本身是不可微操作,梯度只沿 argmax 路径传递。

4.3 三个模块的设计要点小结

模块 前向输出 反向行为 求导公式本质
MyAdd 1 个输出(x1+x2) 梯度复制到两个输入 ∂y/∂x1=∂y/∂x2=1\partial y/\partial x_1 = \partial y/\partial x_2 = 1
MySplit 2 个输出(两个 clone) 两个梯度相加 ∂L/∂x=∂L/∂x1+∂L/∂x2\partial L/\partial x = \partial L/\partial x_1 + \partial L/\partial x_2(链式法则求和)
MyMax 1 个输出(最大值标量) 梯度只流向 argmax 位置 ∂max⁡/∂xi=1\partial \max/\partial x_i = 1(若 xix_i 最大)否则 0

无论自定义哪种模块,都必须遵守同一规则:重写自己的 forward 前向通路,以及在 backward 中定义正确的梯度计算方式,并且 backward 的返回要与 forward 的输入一一对应。

五、总结与仓库延伸阅读

本周实践课把"卷积的几何直觉"与"自动微分的底层机制"串联起来:

  • 卷积层:用 kernel_size 取代矩阵宽度,通过堆叠与平移实现参数共享与局部连接;输出尺寸遵循 n−k+1n-k+1(配合 padding 可保尺寸),权重张量形状为 [out_channels, in_channels, ...kernel_size];
  • autograd:requires_grad 开启追踪,grad_fn 记录运算来源并构成动态计算图,backward() 沿图反向求导(非标量需传 grad_output),torch.no_grad() 在推理时关闭梯度累积;
  • 自定义梯度:继承 torch.autograd.Function 并重写 forward/backward,即可把任意可微操作插入计算图(add 复制梯度、split 累加梯度、max 梯度直达 argmax)。

若想继续深入,可以按以下路径在本仓库中探索:

实践建议:先在 Jupyter 中运行 03-autograd_tutorial.ipynb 的每个 cell,并在执行 a.backward() 之前先手工推导一遍梯度(文档明确要求 "Compute it by hand BEFORE executing this");随后尝试把 MyAdd、MySplit、MyMax 三个自定义模块组合进同一个计算图,观察梯度如何在分支与汇合处流动。环境依赖可参考仓库根目录的 environment.yml。

登录后查看全文
NYU-DLSP20