08. Triton Softmax Backward | Triton Softmax 反向梯度
难度: Hard | 环境: NVIDIA GPU 必需 | 标签: Triton、Softmax、反向传播 | 目标人群: 理解 Softmax 与链式法则
🚀 云端运行环境
本章节的实战代码可以点击以下链接在免费 GPU 算力平台上直接运行:
本节导读
Softmax的各列概率共同满足行和为1。修改一个输入分数,会同时改变其他位置的概率,那么反向传播能否只把对应位置的两个数相乘?
前向概率与损失传来的梯度共同决定一个整行共享的修正项,再由各列分别得到输入梯度。本节从链式法则展开这一关系,并解释“整行平移不改变概率”为何约束反向结果。
运行环境
前置阅读
先理解一行概率如何共同归一化,再回顾链式法则中的上游梯度。
- 07 Softmax 前向:行内最大值、指数和与归约。
- Part00·07 自动微分与反向传播:输出梯度如何沿计算图传回输入。
Step 1:一个位置的梯度为什么依赖整行概率
设一行分数为
每行先求共享标量
Step 2:同一个行点积怎样修正每列梯度
例如
一个 Program 负责一行,先读取该行的概率和上游梯度,归约乘积,再将标量
Step 3:怎样用平移不变性检查反向结果
给整行输入同时加上相同常数,Softmax 概率不变,因此沿这个共同变化方向的损失导数应为零,也就是
另一个可直接检查的输入是整行上游梯度均为常数
Step 4:实现行点积与输入梯度
输入为同设备、同形状、非空的二维 CUDA FP32 张量,分别保存有效 Softmax 概率和上游梯度;行宽不超过 4096。骨架提供连续化、地址、尾部掩码和启动器,补全行内点积与逐列修正两个 TODO。测试对照自动微分,并覆盖非整除行宽、非连续布局、常量梯度和接近单点集中的概率。 填写变量后移除对应局部断言,题目与答案共用给定启动函数。
| TODO / 函数 | 待实现的机制 | 必须满足的约束 | 测试证据 |
|---|---|---|---|
TODO 1:归约行点积softmax_backward_kernel | 汇总本行概率与上游梯度的乘积 | 每行独立,补齐列贡献零 | 多行、非整除行宽与两类视图输入对照自动微分 |
TODO 2:修正逐列梯度softmax_backward_kernel | 用本行共享点积计算输入梯度 | 每列使用自身概率与上游梯度 | 常量/零上游梯度、行梯度和与集中概率检查 |
import torch
import triton
import triton.language as tl@triton.jit
def softmax_backward_kernel(
grad_input_ptr, softmax_output_ptr, grad_output_ptr,
row_stride, n_cols, BLOCK_SIZE: tl.constexpr,
):
"""先归约行内点积,再写回该行的输入梯度。"""
row = tl.program_id(0)
cols = tl.arange(0, BLOCK_SIZE)
mask = cols < n_cols
row_offset = row * row_stride
y = tl.load(softmax_output_ptr + row_offset + cols, mask=mask, other=0.0)
grad_y = tl.load(grad_output_ptr + row_offset + cols, mask=mask, other=0.0)
# TODO 1:由本行 y、grad_y 归约出共享标量。
# row_dot = ??? # 对逐列乘积求和,不跨其他行。
tl.static_assert(False, "TODO 1:请填写 row_dot 并移除此断言")
# TODO 2:每列使用自身概率与同一 row_dot 修正梯度。
# grad_x = ??? # 使用 y、grad_y 和本行 row_dot。
tl.static_assert(False, "TODO 2:请填写 grad_x 并移除此断言")
tl.store(grad_input_ptr + row_offset + cols, grad_x, mask=mask)
def triton_softmax_backward(softmax_output: torch.Tensor, grad_output: torch.Tensor) -> torch.Tensor:
"""从二维 CUDA FP32 概率和上游梯度计算输入梯度,支持非连续视图。"""
if softmax_output.ndim != 2 or grad_output.shape != softmax_output.shape:
raise ValueError("两个输入必须是形状相同的二维张量")
if softmax_output.device != grad_output.device or not softmax_output.is_cuda:
raise ValueError("两个输入必须位于同一 CUDA 设备")
if softmax_output.dtype != torch.float32 or grad_output.dtype != torch.float32:
raise TypeError("本练习仅支持 float32 输入")
rows, columns = softmax_output.shape
if rows < 1 or not 1 <= columns <= 4096:
raise ValueError("输入须非空且行宽为 1–4096")
y = softmax_output.contiguous()
grad_y = grad_output.contiguous()
grad_x = torch.empty_like(y)
with torch.cuda.device(y.device):
softmax_backward_kernel[(rows,)](
grad_x, y, grad_y, y.stride(0), columns,
BLOCK_SIZE=triton.next_power_of_2(columns),
)
return grad_x正确性测试
def _check_backward_case(logits, upstream, layout="contiguous"):
"""以相同概率和上游梯度,对照自动微分并检查行不变量。"""
logits = logits.detach().requires_grad_(True)
probabilities = torch.softmax(logits, dim=-1)
expected, = torch.autograd.grad(probabilities, logits, grad_outputs=upstream)
y, grad_y = probabilities.detach(), upstream
if layout == "transpose":
y = y.t().contiguous().t()
grad_y = grad_y.t().contiguous().t()
elif layout == "slice":
storage_y = torch.empty((y.shape[0], y.shape[1] * 2), device=y.device)
storage_g = torch.empty_like(storage_y)
y_view, g_view = storage_y[:, ::2], storage_g[:, ::2]
y_view.copy_(y)
g_view.copy_(grad_y)
y, grad_y = y_view, g_view
before_y, before_g = y.clone(), grad_y.clone()
actual = triton_softmax_backward(y, grad_y)
assert actual.shape == y.shape and actual.dtype == y.dtype and actual.device == y.device
assert actual.is_contiguous() and torch.isfinite(actual).all()
torch.testing.assert_close(actual, expected, atol=2e-5, rtol=2e-5,
msg=f"shape={tuple(y.shape)}, layout={layout}")
torch.testing.assert_close(actual.sum(dim=-1), torch.zeros(y.shape[0], device=y.device), atol=2e-5, rtol=0)
torch.testing.assert_close(y, before_y, atol=0, rtol=0)
torch.testing.assert_close(grad_y, before_g, atol=0, rtol=0)
def test_softmax_backward():
"""覆盖整行归约、特殊上游梯度、数值范围与非连续布局。"""
if not torch.cuda.is_available():
print("SKIPPED: Softmax 反向核对需要 NVIDIA GPU。")
return {"status": "skipped"}
torch.manual_seed(42)
shapes = [(1, 1), (3, 3), (3, 17), (5, 256), (2, 513), (2, 4096)]
for rows, columns in shapes:
logits = torch.randn(rows, columns, device="cuda")
_check_backward_case(logits, torch.randn_like(logits))
for layout in ("transpose", "slice"):
logits = torch.randn(3, 17, device="cuda")
_check_backward_case(logits, torch.randn_like(logits), layout)
for mode in ("uniform", "peaked", "constant_gradient", "zero_gradient"):
logits = torch.randn(3, 17, device="cuda")
upstream = torch.randn_like(logits)
if mode == "uniform":
logits.zero_()
elif mode == "peaked":
logits.fill_(-80)
logits[:, 0] = 80
elif mode == "constant_gradient":
upstream.fill_(2)
else:
upstream.zero_()
_check_backward_case(logits, upstream)
print("PASSED: Softmax 反向 12 组数值、布局与行不变量核对通过。")
return {"status": "passed", "numeric_cases": 12}
def test_backward_input_contract():
"""在启动 kernel 前拒绝错误形状、设备、类型与空输入。"""
if not torch.cuda.is_available():
print("SKIPPED: 输入契约核对需要 NVIDIA GPU。")
return {"status": "skipped"}
y = torch.ones((2, 3), device="cuda") / 3
bad = [(y.cpu(), y), (y, y.cpu()), (y.flatten(), y.flatten()),
(y, y[:, :2]), (y.double(), y), (y, y.half()),
(y[:0], y[:0]), (y[:, :0], y[:, :0]),
(y.unsqueeze(0), y.unsqueeze(0)),
(torch.empty((1, 4097), device="cuda"), torch.empty((1, 4097), device="cuda"))]
for index, (left, right) in enumerate(bad, 1):
try:
triton_softmax_backward(left, right)
except (ValueError, TypeError):
continue
raise AssertionError(f"非法输入 {index} 未被拒绝")
print(f"PASSED: Softmax 反向 {len(bad)} 组输入约束核对通过。")
return {"status": "passed", "invalid_cases": len(bad)}
test_softmax_backward()
test_backward_input_contract()参考代码与解析
代码
@triton.jit
def softmax_backward_kernel(
grad_input_ptr, softmax_output_ptr, grad_output_ptr,
row_stride, n_cols, BLOCK_SIZE: tl.constexpr,
):
"""先归约行内点积,再写回该行的输入梯度。"""
row = tl.program_id(0)
cols = tl.arange(0, BLOCK_SIZE)
mask = cols < n_cols
row_offset = row * row_stride
y = tl.load(softmax_output_ptr + row_offset + cols, mask=mask, other=0.0)
grad_y = tl.load(grad_output_ptr + row_offset + cols, mask=mask, other=0.0)
# TODO 1:由本行 y、grad_y 归约出共享标量。
row_dot = tl.sum(y * grad_y, axis=0)
# TODO 2:每列使用自身概率与同一 row_dot 修正梯度。
grad_x = y * (grad_y - row_dot)
tl.store(grad_input_ptr + row_offset + cols, grad_x, mask=mask)
def triton_softmax_backward(softmax_output: torch.Tensor, grad_output: torch.Tensor) -> torch.Tensor:
"""从二维 CUDA FP32 概率和上游梯度计算输入梯度,支持非连续视图。"""
if softmax_output.ndim != 2 or grad_output.shape != softmax_output.shape:
raise ValueError("两个输入必须是形状相同的二维张量")
if softmax_output.device != grad_output.device or not softmax_output.is_cuda:
raise ValueError("两个输入必须位于同一 CUDA 设备")
if softmax_output.dtype != torch.float32 or grad_output.dtype != torch.float32:
raise TypeError("本练习仅支持 float32 输入")
rows, columns = softmax_output.shape
if rows < 1 or not 1 <= columns <= 4096:
raise ValueError("输入须非空且行宽为 1–4096")
y = softmax_output.contiguous()
grad_y = grad_output.contiguous()
grad_x = torch.empty_like(y)
with torch.cuda.device(y.device):
softmax_backward_kernel[(rows,)](
grad_x, y, grad_y, y.stride(0), columns,
BLOCK_SIZE=triton.next_power_of_2(columns),
)
return grad_x解析
TODO 1:归约本行概率与梯度的点积
- 各列通过共同分母耦合,行共享项必须包含全部有效位置的
y * grad_y,而不能取一列或只累加上游梯度。 tl.sum(y * grad_y, axis=0)得到当前行标量;非整除行宽和非连续输入经给定骨架加载后,与自动微分逐元素对照。
TODO 2:使用共享项修正逐列梯度
- 本列的概率乘
grad_y - row_dot,保留局部影响并减去整行贡献;遗漏减法会破坏平移不变性。 - 常量/零上游梯度应得到零输出,普通输入还需满足行梯度和接近零;这些断言与参考梯度同时检查,不能互相替代。
相关阅读
继续把当前行梯度公式接到分块注意力与模型的反向路径。
- Part02·10:Attention 反向与自定义 Autograd:Softmax 梯度怎样继续传给 Q、K、V。
- 11 FlashAttention:前向概率不完整写出时,跨块归一化状态怎样保留。
