NYU DLSP20 第 5 周实操:用 PyTorch 理解一维/二维卷积与自动微分引擎
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 周实践课(线性代数与卷积)中,输入通过全连接矩阵 与向量 相乘得到输出。本周我们要探索自然数据的三个性质——稀疏性(sparsity)、平稳性(stationarity)与组合性(compositionality)——正是这些性质催生了卷积运算。
关键转变在于:不再使用宽度为 的稠密矩阵 ,而是把矩阵宽度改成卷积核尺寸 。这样一来,矩阵的每一行都可以被解释为一个独立的 kernel(卷积核)。通过"堆叠(stacking)"多个 kernel 获得厚度(通道数),通过"平移(shifting)"让同一个 kernel 在输入序列的不同位置上滑动,就构成了卷积层。
若输入长度为 、kernel 尺寸为 ,则每个 kernel 在每个位置上做一次局部运算,输出长度为:
堆叠 个 kernel 后,卷积层的输出就是 个(厚度方向)长度为 的向量(见下图)。
一个朴素的输入向量可以被看作单声道(monophonic)信号:每个时间点只有 1 个数值。
1.1 输入的形式化定义:从标量序列到通道映射
把输入 正式写成映射:
其中 。因为这是一维信号,定义域是 1 维的; 是通道数。当 时是单声道信号,当 时就是立体声(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 通道,信号长度:
偏置的个数与输出通道数一致——每个输出通道(每个 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 个尺寸为 的 kernel。
卷积后输出仍是 1 张图像、16 个通道,高度和宽度分别变为:
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),其含义是:在 (高度)方向各补 1 像素(图像上方 1 个、下方 1 个),在 (宽度)方向各补 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])
这里蕴含的通用公式是:补零后输出尺寸 。当 kernel 为 3 时,padding=1 即可"保尺寸";当 kernel 宽为 5 时,则需 padding=2。这也是后面 06-convnet.ipynb 中 CNN 网络反复使用的保尺寸技巧。
三、自动梯度(autograd)是如何工作的?
这一节我们让 PyTorch 追踪张量上的全部运算,从而自动完成偏导数的计算。配套的 03-autograd_tutorial.ipynb 完整演示了整个过程。
3.1 一个完整的追踪-反向传播示例
步骤如下:
- 创建 的张量 ,开启梯度累积能力(
requires_grad=True); - 让所有元素减去 2,得到 ;
- 继续运算:;
- 对 求平均得到标量 。
# 创建 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)就是用来计算梯度的。在本例中,反向传播过程可以看作计算 。先手工推导作为验证:
执行 a.backward() 后,x.grad 会与上述手工计算完全一致:
a.backward()
print(x.grad)
# tensor([[-1.5000, 0.0000],
# [ 1.5000, 3.0000]])
值得强调一个容易混淆的细节:在 PyTorch 中求偏导时,得到的梯度形状与原始数据形状相同;而数学上正确的 Jacobian 应当是它的转置。也就是说,PyTorch 的 x.grad 存放的是 的逐元素值,与 的布局对应关系需要结合具体求导语境理解。
3.3 从基础走向"疯狂":动态图中的循环求导
现在我们有一个 的向量 ,令 为 的两倍,然后不断把 翻倍,直到其范数小于 1000:
x = torch.randn(3, requires_grad=True)
y = x * 2
i = 0
while y.data.norm() < 1000:
y = y * 2
i += 1
由于 是随机生成的,我们无法预知循环会执行多少次。但借助梯度可以轻松推断出迭代次数。因为 是标量倍数关系,反向传播时我们需要为 backward() 指定一个与 同形状的梯度种子(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 明确"我想要追踪梯度累积";反之,如果省略该参数,梯度就不会累积。示例: 与 都允许梯度累积时:
# 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.])
可以手动验证:,故 ,。
如果 或 声明时省略了 requires_grad=True,再对 调用 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
加法把两个对象合并为一个输出:前向直接相加;反向时梯度需要同时复制到两个输入上( 对两个输入的偏导都是 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
分裂模块的语义是"从一个张量分出两个副本"。由于前向产生两个输出,反向就会收到两个梯度(分别对应两个输出);而这两个梯度都源自同一个输入 ,所以反向时应当把两个梯度相加( 对最终损失的贡献是两条路径之和)。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) | 梯度复制到两个输入 | |
MySplit |
2 个输出(两个 clone) | 两个梯度相加 | (链式法则求和) |
MyMax |
1 个输出(最大值标量) | 梯度只流向 argmax 位置 | (若 最大)否则 0 |
无论自定义哪种模块,都必须遵守同一规则:重写自己的 forward 前向通路,以及在 backward 中定义正确的梯度计算方式,并且 backward 的返回要与 forward 的输入一一对应。
五、总结与仓库延伸阅读
本周实践课把"卷积的几何直觉"与"自动微分的底层机制"串联起来:
- 卷积层:用
kernel_size取代矩阵宽度,通过堆叠与平移实现参数共享与局部连接;输出尺寸遵循 (配合 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)。
若想继续深入,可以按以下路径在本仓库中探索:
- 本讲配套实操 notebook:03-autograd_tutorial.ipynb(自动梯度全程演示)、extra/b-custom_grads.ipynb(自定义可微模块);
- 一维卷积的进一步应用("听"卷积核):07-listening_to_kernels.ipynb;
- 卷积网络在图像分类上的完整案例:06-convnet.ipynb;
- 英文原版讲义:docs/en/week05/05-3.md;本周课程总览见 docs/it/week05/05.md。
实践建议:先在 Jupyter 中运行 03-autograd_tutorial.ipynb 的每个 cell,并在执行
a.backward()之前先手工推导一遍梯度(文档明确要求 "Compute it by hand BEFORE executing this");随后尝试把MyAdd、MySplit、MyMax三个自定义模块组合进同一个计算图,观察梯度如何在分支与汇合处流动。环境依赖可参考仓库根目录的 environment.yml。




