Skip to content

线性代数与张量计算

解析大模型中的高维张量缩并、爱因斯坦求和、FLOPs 估算(6ND/2N)及 SVD 低秩分解。

当前:讲解模式 — 侧重直觉建立、生活类比与分步拆解快捷键 M 切换
概念定义 · 什么是张量与矩阵乘法?

张量(Tensor) 是大模型里存放所有数据的通用容器:单个数字是 0 维张量,一串特征是 1 维向量,表格是 2 维矩阵,而一段批量文本的表示就是 3 维或 4 维张量。

大模型每次“思考”(前向推理)本质上都是在把输入张量与数十亿权重矩阵反复相乘(GEMM);而 低秩分解(SVD) 则是把一个又胖又重的矩阵拆成两个瘦长小矩阵相乘的压缩基本功,是后面 LoRA、MLA 等省显存算法的共同地基。

01 为什么大模型绕不开张量与矩阵乘法? ​

表面上看,大语言模型能写诗、写代码、做数学题;可一旦剥开外壳往 GPU 里瞧,你会发现它干的几乎全是一件事:把一大堆数字排成多维方阵,疯狂地做矩阵乘法(GEMM)。

早期 NLP 使用 RNN 一个词一个词地串行处理,就像小作坊里的手工师傅,必须缝完上一针才能缝下一针,GPU 里成千上万个计算核心只能干瞪眼。直到 Transformer(Attention Is All You Need, 2017 ↗)把整句话所有词元一次性打包成高维张量并行计算,大模型的算力闸门才真正被打开。

类比 · 手工作坊 vs 超级集装箱码头

如果把神经网络比作一座物流港,标量是一颗螺丝,向量是一排货架,矩阵是一整面货柜墙,而 张量(Tensor) 就是贴满维度标签(第几条样本 B、第几个词 S、第几个注意力头 H、第几维特征 d)的立体集装箱阵。GPU 的 Tensor Core 就像专吃标准集装箱的巨型龙门吊——只要你把数据规整地塞进矩阵乘法,它每秒就能吞吐上千万亿次运算。

核心设问

面对四维、五维张量满天飞的大模型工程,我们怎么做到三件事:第一,写代码时不把维度转晕?第二,一眼估算出训练和推理分别要烧多少算力、到底卡在计算还是卡在显存?第三,怎么把动辄几百 GB 的参数矩阵优雅地“瘦身”?

02 三个让底层立刻通透的生活类比 ​

要打通大模型的线性代数直觉,抓住这三个画面就够了:

画面一:Stride 步长与 einsum 调度单 ​

很多新手以为调用 transpose() 或 permute() 会把显存里的数据搬得天翻地覆。其实张量在显存里始终只是一长条一维数组,多维形状全靠一张“索引换算表”——也就是 步长(Stride) 来解释。转置只是改写换算表上的数字(零拷贝),就像仓库管理员不搬动集装箱,只在清单上把“按行编号”改成“按列编号”。

而 爱因斯坦求和(einsum) 则是更直观的物流调度单:比如 einsum("bhid,bhjd->bhij", Q, K),规则简单到只需记住一句话——等号右边消失的字母(d)就拿来做乘加求和,留下来的字母(b, h, i, j)原封不动当外壳。写多头注意力再也不用对着 transpose(-2, -1) 数指头了。

画面二:厨师切菜 vs 跑仓库(屋顶线与算术强度) ​

为什么同样一张 H100 显卡,训练模型和首字预填充(Prefill)跑得风驰电掣,轮到逐字吐答案(Decode)却突然慢如蜗牛?答案藏在 算术强度(Arithmetic Intensity) 与 Roofline 屋顶线模型 (2009) ↗ 里。

类比 · 顶级大厨为什么被传菜员拖垮?

把 GPU 算力想象成切菜快到出残影的米其林大厨,把显存带宽想象成从冰库往灶台端食材的传菜员:

  • 训练 / Prefill(GEMM,大矩阵乘大矩阵):传菜员搬出一整箱权重,大厨一口气拿它给几千个词元同时做菜,端一次料能切很久——瓶颈在大厨手速(计算受限 Compute-bound)。
  • 单请求逐字生成(GEMV,向量乘矩阵):每吐一个新词,传菜员都要把几十 GB 的整套权重从 HBM 显存搬进核心,大厨只用它算区区 1 个词元就扔了——99% 的时间大厨都在叉腰等菜(访存受限 Memory-bound)。

画面三:SVD 低秩分解——用几笔主干画出风景照 ​

一个 4096×4096 的权重矩阵藏着 1600 多万个数字,但它们真的各自独立吗?奇异值分解(SVD)告诉我们:绝大多数真实权重矩阵的能量高度集中在少数几个主方向上。

类比 · 风景油画的极简分层

你可以把全秩矩阵想象成一张 4K 高清风景照,而 SVD 低秩近似 就像请画家把它拆成几层透明胶片:第一张胶片只画天空与大地的主色调(最大奇异值 σ1),第二张补上远山轮廓(σ2),第三张勾勒树林细节(σ3)……只保留前 r 张主胶片,就已经还原了绝大部分视觉信息,而存储体积瞬间缩水几十倍。

03 把关键公式读成人话 ​

首先是评估大模型算力账本的两条黄金经验式(详见 Kaplan Scaling Laws, 2020 ↗ 与 Megatron-LM, 2021 ↗):

Cinfer/token≈2N,Ctrain≈6ND

把 2N 和 6ND 读成直觉:- 为什么推理是 2N? 每个参数在前向传播处理 1 个词元时,恰好只参与 1 次乘法和 1 次加法(共 2 次浮点运算),乘以 N 个参数就是 2N。

  • 为什么训练是 6ND? 前向花 2N;反向传播 要同时算“传给上一层的梯度”和“更新自身权重的梯度”,各花 2N,合计 4N。前向加反向每词元共 6N,再乘以训练总词元数 D,就得到一眼估算百万美元账单的 6ND(若开启 激活重计算 省显存,会多做一遍前向,系数变成 8ND)。

再来看衡量算子到底卡算力还是卡显存的算术强度公式(以 2 字节的 BF16 为例):

AI=2MKN2(MK+KN+MN)=MKNMK+KN+MN FLOPs/Byte

**把算术强度读成直觉:**分子是“做了多少次计算”,分母是“搬了多少字节数据”。当单条请求逐字解码时 M=1,分母里的 KN 把整个式子吃死,AI≈1——相当于每搬 1 字节权重只算 1 次浮点,远低于 H100 约 300 FLOPs/Byte 的拐点。这就是为什么推理引擎拼命做 Continuous Batching(把 M 凑大)与 量化压缩(把每个权重的字节数压小)。

最后是低秩压缩的数学核心——截断 SVD:

W≈Wr=∑i=1rσiuivi⊤=BA

**把低秩分解读成直觉:**原本从 K 维直接跳到 N 维需要 K×N 个参数;现在先经过一条宽度只有 r 的窄桥 A∈RK×r,再展开成 B∈Rr×N,参数量降为 r(K+N)。当 r≪min(K,N) 时,计算和显存双双断崖式下降,而 Eckart–Young–Mirsky 定理保证了按最大奇异值截断就是数学上误差最小的方案。

04 它在模型里怎么工作 & 与上下游的关系 ​

张量计算并非孤立的数学课,而是贯穿整个 LLM 生命周期的通用骨架:

05 算子画像对比与三个避坑备忘 ​

计算形态典型维度瓶颈类型工程提速抓手
大批量 GEMM(M,K)×(K,N)计算受限维度对齐 64/128、使用 FP8/BF16 Tensor Core
逐字解码 GEMV(1,K)×(K,N)强访存受限增大 Batch、权重量化(INT4/FP8)、投机解码
低秩投影(M,K)→(M,r)→(M,N)极省参数与显存LoRA 适配、MLA 矩阵吸收
逐点操作(B,S,d)强访存受限算子融合(torch.compile / Triton)减少 HBM 往返
  1. 别盲信 6ND:它默认序列不算太长且是稠密模型。遇到 128K 超长文本时,注意力的 4LSd 二次项会喧宾夺主;遇到 MoE 混合专家模型,必须代激活参数量而非总参数量。
  2. 矩阵维度尽量凑 8 / 64 的倍数:哪怕真实词表是 50,257,工业界也会向上补齐到 50,304,防止 Tensor Core 退化到慢速边缘内核。
  3. 转置后小心 reshape 的暗中拷贝:view 要求内存连续,而 reshape 遇到非连续张量会悄悄申请新显存并整块搬运;在热路径上反复触发,吞吐会莫名掉一大截。

需要查阅完整矩阵步长推导、Roofline 公式详情以及可运行的 einsum 注意力、SVD 压缩与 FLOPs 估算 PyTorch 代码?按快捷键 M 或点击顶部 技术 Wiki 即可随时切换。

大语言模型(Large Language Model, LLM)的本质是一个由海量线性变换与逐点非线性激活函数复合而成的可微函数。无论是 词元嵌入(Embedding)、多头自注意力(Multi-Head Self-Attention),还是 前馈网络(FFN) 与 低秩微调(LoRA),其底层算子几乎全部归结为高维张量(Tensor)的矩阵乘法(GEMM)与低秩分解。掌握张量形状语义、爱因斯坦求和约定、算力复杂度(FLOPs)与屋顶线模型(Roofline Model),是理解现代 Transformer 架构 设计与底层硬件优化的第一步。

直观理解

如果把大语言模型看作一条全自动装配流水线,张量就是流水线上带有多个维度标签(批次、序列长度、注意力头、隐藏维度)的数据集装箱,矩阵乘法(GEMM) 是流水线上最核心的通用加工机床,einsum 是精准描述集装箱如何对齐与合并的调度单,而 SVD 低秩分解则是用少数几个主干零件去近似表示庞大参数仓库的压缩蓝图。

问题动机与演进背景 ​

在早期自然语言处理中,统计模型与循环神经网络(RNN)往往按时间步串行处理一维向量,难以充分利用现代 GPU 的大规模并行算力。自 Transformer 架构提出以来,序列中所有位置的计算被统一组织为高维张量的批量矩阵乘法(Batched GEMM),从而与 GPU Tensor Core 的脉动阵列硬件高度契合。

然而,随着参数量从数亿跃升至数千亿,工程与研究团队面临三个核心挑战:

  1. 高维维度管理复杂:多头注意力、分组查询注意力(GQA) 与 张量并行 引入了 4D 甚至 5D 张量,手工 transpose 与 view 极易引发隐蔽的维度错位。
  2. 算力与访存失衡:大模型的训练与推理分别呈现计算受限(Compute-bound)与访存受限(Memory-bound)特征,必须通过精确的 FLOPs 与算术强度(Arithmetic Intensity)估算指导架构与并行策略。
  3. 参数冗余与微调开销巨大:全参数矩阵存储与更新成本高昂,亟需借助奇异值分解(SVD)等线性代数工具刻画权重矩阵的内在低秩结构。

核心原理与数学推导 ​

1. 张量布局与矩阵乘法(GEMM) ​

在 LLM 中,隐藏状态通常表示为三维张量 X∈RB×S×d,其中 B 为批大小(Batch Size),S 为序列长度(Sequence Length),d 为隐藏维度(Hidden Size)。线性层权重为 W∈Rdin×dout。

对于一般矩阵乘法 C=AB,其中 A∈RM×K,B∈RK×N,结果 C∈RM×N 的每个元素定义为:

Cm,n=∑k=1KAm,kBk,n

计算一个元素需要 K 次乘法和 K−1 次加法(工程上以一次乘加 FMA 计为 2 FLOPs),因此整次 GEMM 的总浮点运算次数为:

FLOPs(GEMMM,K,N)=2MKN

而在内存中,张量按行优先(Row-major) 连续存储,多维索引 (i0,i1,…,ir−1) 到一维线性偏移的映射由步长(Stride) s 决定:

offset(i0,…,ir−1)=∑j=0r−1ij⋅sj

诸如 transpose 或 permute 仅修改元数据步长而不复制底层内存(Zero-copy),但可能破坏内存连续性;调用 contiguous() 或 reshape 时才会触发实际的显存重排。

2. 爱因斯坦求和约定(Einstein Summation, einsum) ​

为了消除繁琐的维度转置与广播语义,现代深度学习框架普遍支持 einsum。其核心规则极为简洁:在输入下标中出现、但在输出下标中消失的索引,沿该维度求和(缩并);在输入输出中共同出现的索引予以保留(批处理或外积)。

以多头自注意力的查询-键分数计算为例,设 Q∈RB×H×Sq×dk,K∈RB×H×Sk×dk,则分数张量 A∈RB×H×Sq×Sk 可写成:

Ab,h,i,j=∑d=1dkQb,h,i,dKb,h,j,d⟺einsum("bhid,bhjd->bhij", Q, K)

通过单行符号即可明确表达批处理维度 (b,h)、外积维度 (i,j) 与缩并维度 d,避免人工转置错误。

3. Transformer 的 2N 推理与 6ND 训练 FLOPs 估算 ​

对于参数量为 N 的密集(Dense)Transformer 模型,每个线性投影参数在单次前向传播中恰好参与一次乘加运算(即 2 FLOPs):

  • 前向传播(Forward):处理 1 个词元,所有线性层(QKV 投影、输出投影、FFN 门控与上下投影)合计约消耗 2N FLOPs。
  • 反向传播(Backward):对于 Y=XW,反向阶段需要分别计算对输入的梯度 ∇XL=(∇YL)W⊤(2 FLOPs/参数)与对权重的梯度 ∇WL=X⊤(∇YL)(2 FLOPs/参数),合计约为前向的 2 倍,即 4N FLOPs。

综合前向与 反向传播,训练 D 个词元的总计算量满足著名的 6ND 近似公式(若启用 激活重计算(Activation Checkpointing),需额外增加一次前向,系数升至约 8ND),这也是 缩放定律(Scaling Laws) 估算算力预算的直接依据:

Cinfer/token≈2N,Ctrain≈6ND

当序列长度 S 较长时,还需加上自注意力矩阵乘法项(每层每词元额外贡献 4Sd 的前向 FLOPs,跨 L 层共 4LSd):

Cforward/token=2Nnon-emb+4LSd

此外,衡量算子是否受限于显存带宽的关键指标是算术强度(Arithmetic Intensity, AI),定义为浮点运算量与访存字节数之比。对 FP16/BF16(每元素 2 字节)下的 GEMMM,K,N:

AI=2MKN2(MK+KN+MN)=MKNMK+KN+MN FLOPs/Byte

当 M=1(自回归解码 Batch Size 为 1 的 GEMV 场景)且 K,N≫1 时,AI≈KNK+KN+N≈1 FLOPs/Byte,远低于现代 GPU(如 H100 FP16 约 300 FLOPs/Byte)的硬件拐点,因此解码阶段高度受限于显存带宽。

4. 奇异值分解(SVD)与低秩近似 ​

任意实矩阵 W∈Rm×n 均可分解为:

W=UΣV⊤=∑i=1rmaxσiuivi⊤

其中 U∈Rm×m 与 V∈Rn×n 为正交矩阵,Σ=diag(σ1,σ2,…) 包含按降序排列的非负奇异值 σ1≥σ2≥⋯≥0。

根据 Eckart–Young–Mirsky 定理,若仅保留前 r 个最大奇异值构造秩-r 矩阵 Wr=U:,:rΣ:r,:rV:,:r⊤,则 Wr 在 Frobenius 范数与谱范数(Spectral Norm)意义下均为最优低秩逼近,其截断误差满足:

∥W−Wr∥F=∑i=r+1min(m,n)σi2,∥W−Wr∥2=σr+1

这一性质直接奠定了 LoRA(用 ΔW=BA 拟合低秩增量)、MLA(对 KV 缓存做低秩潜空间压缩)以及 模型剪枝与蒸馏 的数学基础。

算法架构 / 数据流图 ​

图表加载中...

复杂度与横向对比表 ​

计算原语 / 场景张量形态计算量(FLOPs)访存量(BF16 Bytes)算术强度特征典型应用场景
矩阵-向量乘(GEMV)(1,K)×(K,N)2KN≈2KN≈1(强访存受限)单请求自回归解码(Decode)
矩阵-矩阵乘(GEMM)(M,K)×(K,N)2MKN2(MK+KN+MN)随 M 增大升至计算受限预训练、Prefill、大 Batch 推理
低秩分解投影(M,K)×(K,r)×(r,N)2Mr(K+N)2(MK+Kr+rN+MN)参数量降至 r(K+N)KNLoRA 微调、MLA KV 压缩
逐点操作(Elementwise)(B,S,d)c⋅BSd4BSd(读+写)<1(强访存受限)LayerNorm、激活函数、残差加

核心 PyTorch 参考实现 ​

python
import torch
import torch.nn as nn


def einsum_attention_demo(
    q: torch.Tensor,  # [B, H, S_q, d_k]
    k: torch.Tensor,  # [B, H, S_k, d_k]
    v: torch.Tensor,  # [B, H, S_k, d_v]
) -> torch.Tensor:
    """使用 einsum 表达标准多头缩放点积注意力。"""
    d_k = q.shape[-1]
    # scores: [B, H, S_q, S_k]
    scores = torch.einsum("bhid,bhjd->bhij", q, k) * (d_k ** -0.5)
    attn_weights = torch.softmax(scores, dim=-1)  # [B, H, S_q, S_k]
    # out: [B, H, S_q, d_v]
    out = torch.einsum("bhij,bhjd->bhid", attn_weights, v)
    return out


def svd_low_rank_compress(weight: torch.Tensor, rank: int) -> tuple[torch.Tensor, torch.Tensor, float]:
    """将权重矩阵 W [d_out, d_in] 分解为 B [d_out, r] 与 A [r, d_in],返回相对重构误差。"""
    # full_matrices=False 得到精简 SVD: U [d_out, k], S [k], Vh [k, d_in]
    u, s, vh = torch.linalg.svd(weight.float(), full_matrices=False)
    u_r = u[:, :rank]                          # [d_out, r]
    s_r = torch.sqrt(s[:rank])                 # [r]
    vh_r = vh[:rank, :]                        # [r, d_in]

    mat_b = u_r * s_r.unsqueeze(0)             # [d_out, r]
    mat_a = s_r.unsqueeze(1) * vh_r            # [r, d_in]

    approx = mat_b @ mat_a                     # [d_out, d_in]
    rel_err = (torch.norm(weight.float() - approx) / torch.norm(weight.float())).item()
    return mat_b.to(weight.dtype), mat_a.to(weight.dtype), rel_err


def estimate_transformer_flops(
    num_params: int,
    num_layers: int,
    seq_len: int,
    hidden_size: int,
    num_tokens: int,
    activation_checkpointing: bool = False,
) -> dict[str, float]:
    """估算 Dense Transformer 的前向单词元及完整训练 FLOPs。"""
    fwd_linear = 2 * num_params
    fwd_attn = 4 * num_layers * seq_len * hidden_size
    fwd_per_token = fwd_linear + fwd_attn
    # 反向约为前向的 2 倍;开启激活重计算需多做 1 次前向
    multiplier = 4.0 if activation_checkpointing else 3.0
    total_train_flops = multiplier * fwd_per_token * num_tokens
    return {
        "fwd_flops_per_token": float(fwd_per_token),
        "approx_6nd_flops": float(6 * num_params * num_tokens),
        "exact_train_flops": float(total_train_flops),
    }


if __name__ == "__main__":
    torch.manual_seed(42)
    B, H, S, D = 2, 8, 16, 64
    q = torch.randn(B, H, S, D)
    k = torch.randn(B, H, S, D)
    v = torch.randn(B, H, S, D)
    out = einsum_attention_demo(q, k, v)
    assert out.shape == (B, H, S, D)

    # 构造带噪声的低秩矩阵测试 SVD 压缩
    w_true = torch.randn(512, 16) @ torch.randn(16, 512) + 0.05 * torch.randn(512, 512)
    b_mat, a_mat, err = svd_low_rank_compress(w_true, rank=16)
    print(f"SVD rank-16 相对 Frobenius 误差: {err:.4f}, 压缩后形状: B={tuple(b_mat.shape)}, A={tuple(a_mat.shape)}")

    stats = estimate_transformer_flops(
        num_params=7_000_000_000,
        num_layers=32,
        seq_len=4096,
        hidden_size=4096,
        num_tokens=1_000_000_000_000,
    )
    print(f"7B/1T tokens 估算训练量: {stats['exact_train_flops']:.3e} FLOPs (6ND={stats['approx_6nd_flops']:.3e})")

工程实践与常见陷阱 ​

工程实践

  1. 维度对齐硬件 Tile:在 NVIDIA Tensor Core 上,将矩阵维度 M,N,K 设置为 8(FP16/BF16)或 16(FP8/INT8)的倍数,甚至 64/128 的倍数,可避免 cuBLAS 退化到低效内核,显著提升 MFU(Model FLOPs Utilization)。
  2. 善用算子融合(Kernel Fusion):逐点操作(激活、残差、归一化)算术强度极低,应尽量通过 torch.compile 或 Triton 将其融合进相邻读写中,减少 HBM 往返流量。
  3. 利用 einsum 优化缩并路径:对三阶及以上多张量缩并,直接使用 PyTorch 的 torch.einsum(内置基于 opt_einsum 的启发式路径规划),避免手动先生成巨大中间张量导致 OOM。

常见陷阱

  1. 忽略 6ND 的适用边界:6ND 假设词表嵌入层占比可忽略且序列长度 S≪6d。当模型很小(词表占比高)或上下文极长(如 S=128k)时,注意力二次项 4LSd 会显著抬升真实计算量;MoE 模型则必须用激活参数量 Nactive 而非总参数量 Ntotal 代入估算。
  2. 混淆 view 与 reshape 的隐式拷贝:对转置后的非连续张量调用 reshape 会静默分配新显存并拷贝数据,在长序列热点路径上反复触发会严重拖慢吞吐并增加峰值显存。
  3. 低精度下的 SVD 数值不稳定:直接在 FP16/BF16 上做矩阵分解极易因条件数过大而出现 NaN 或奇异值失真,实践中务必先 .float() 转 FP32 计算分解再转回目标精度。

延伸阅读与参考论文 ​

  • Golub, G. H., & Van Loan, C. F. (2013). Matrix Computations (4th ed.). Johns Hopkins University Press. 图书主页 ↗
  • Vaswani, A., et al. (2017). Attention Is All You Need. NeurIPS 2017. arXiv:1706.03762 ↗
  • Kaplan, J., et al. (2020). Scaling Laws for Neural Language Models. arXiv:2001.08361 ↗
  • Narayanan, D., et al. (2021). Efficient Large-Scale Language Model Training on GPU Clusters Using Megatron-LM. SC21. arXiv:2104.04473 ↗
  • Williams, S., Waterman, A., & Patterson, D. (2009). Roofline: An Insightful Visual Performance Model for Multicore Architectures. CACM. DOI:10.1145/1498765.1498785 ↗
  • Hu, E. J., et al. (2021). LoRA: Low-Rank Adaptation of Large Language Models. ICLR 2022. arXiv:2106.09685 ↗