推荐系统的训练脚本里,有一张特征权重表:12 个特征,每个特征对三个目标各有一组权重,分别对应点击、收藏、转发。最初大家手写打分公式,score1 = w11*x1 + w12*x2 + ...,12 行还能忍,至少能在表格里一行一行对照,改完再核对一遍。

等特征扩到 50 个,代码里就出现了 50 个乘法连着 50 个加法,改一个权重要把整行重新对齐,漏掉一项也不会报错,只会静默地算出一个偏小的分数。再往后接入 embedding 表,10000 行、每行 128 维,有人估内存说「大概 5 MB」,另一个人算出 20 MB,两个人拿着同一张表,数字差了 4 倍。

这两个场景都指向同一组基础概念:向量负责装一条输入,矩阵负责把输入批量地变成输出,张量负责再多装几维。这篇从那张权重表出发,讲清它们各自是什么、形状怎么读、乘法在算什么、内存怎么估,以及形状对不上时按什么顺序排查。

向量就是一串有序的数

向量(vector)是一串按顺序排好的数。其中每个数叫一个分量(component),分量的个数叫维度(dimension)。一个 12 维向量就是 12 个数排成一行,第 1 个数是第 1 个特征,第 12 个数是第 12 个特征。

顺序是向量的一部分,不是排版细节。二维平面上,(1, 2) 和 (2, 1) 指向两个不同的位置;在特征表里,如果把「最近七天点击次数」和「客单价」两列对调,模型学到的权重含义也跟着错位。数字本身没变,含义全变了。

同一条数组,在工程里通常扮演三种角色。第一种,一条样本的特征:年龄、点击次数、客单价、停留时长等拼成一个 12 维向量,送进模型打分。第二种,空间里的一个点或方向:从原点出发,两个分量就是横纵坐标,三个分量就是 x、y、z。第三种,一个词的嵌入(embedding):词表里每个词对应一个 128 维向量,词与词的夹角和距离被用来表达语义相近。

三种角色共用同一套加法、数乘和点积,但解释不能混。做特征时关心每个分量的单位和量纲,做几何时关心长度和夹角,做嵌入时关心相似度。混着解释就会写出没有意义的比较,比如拿「年龄 30」和「点击 0.3 次」比大小,或者把两个量纲完全不同的维度直接算距离。

举一个具体的例子。一句「今天下雨」,分词后得到三个词,每个词查表得到一个 128 维向量,整句话既可以堆成 3×128 的矩阵,也可以把三个向量求平均压成一个 128 维摘要。同一句话,两种形状,下游能做的事不一样:堆成矩阵可以继续按词处理,压成摘要只能整体比较。

两个向量的点积还能给出夹角:点积除以两个长度,得到余弦值。做推荐时常用它衡量用户向量和物品向量有多接近,但前提是各维已经缩放到可比较的尺度,否则某个数值大的特征会独占结果。

排版上还有行向量和列向量的区别。行向量横着写,形如 [x1 x2 x3];列向量竖着写,形如 3 行 1 列。它们装的是同一组数,区别在于参与乘法时站的位置。约定是矩阵在左、向量在右,向量写成列:

x = [ 1.0 ]
    [ 0.5 ]
    [ 2.0 ]

如果你拿一个行向量去右乘矩阵,很多库会直接报形状错误,或者按另一条规则把它解释成内积。看到「同样的数,换个写法结果不对」,先检查这里,再怀疑算法。

矩阵是按行列排的数表,本质是批量做同一件事

矩阵(matrix)是按行和列排好的数表,形状写成 m×n,表示 m 行 n 列。第 i 行第 j 列的元素记作 aij。行数和列数不能随便省略,它们是矩阵身份的一部分。

矩阵的本职不是「装数据」,而是「批量做同一件事」。一个 12×3 的权重矩阵,把 12 维输入变成 3 维输出:每一行负责算一个输出,行里 12 个数就是该输出对 12 个输入的权重。三条行规则同时工作,一次得到三个分数,所以叫批量。

矩阵和向量之间还有一个容易忽略的关系:12×3 的矩阵转置之后是 3×12。乘法的方向决定了谁被当成批量。把样本按行堆成 (batch, n),权重按 (n, m) 放,结果就是 (batch, m),这是深度学习框架最常见的排法。形状里第一个位置是样本,第二个位置是特征或输出,读错这个顺序,后面的广播和转置都会跟着错。

一次处理两条样本,就是把这个动作重复两遍。下面用纯 Python 写嵌套循环,不引入任何第三方库。代码里的 W 按 3 行 12 列存放,正好是 12 维进、3 维出:

W = [
    [0.50, 0.10, -0.20, 0.30, 0.00, 0.20, 0.40, -0.30, 0.10, 0.60, -0.10, 0.20],
    [-0.20, 0.40, 0.00, 0.10, -0.50, 0.30, -0.10, 0.20, 0.10, 0.00, 0.50, -0.40],
    [0.10, -0.30, 0.50, 0.20, 0.40, 0.10, 0.00, 0.60, -0.20, 0.30, 0.20, 0.10],
]
X = [
    [1.0, 0.5, 2.0, 1.5, 0.0, 3.0, 1.0, 2.5, 0.5, 1.0, 2.0, 0.0],
    [0.5, 1.5, 0.0, 2.0, 1.0, 1.0, 2.5, 0.0, 1.5, 0.5, 1.0, 2.0],
]

def matvec(W, x):
    out = []
    for row in W:
        s = 0.0
        for w, v in zip(row, x):
            s += w * v
        out.append(s)
    return out

for i, x in enumerate(X, 1):
    y = matvec(W, x)
    print("sample %d: %s" % (i, ["%.2f" % v for v in y]))

在本机 Python 3.15 上跑,输出是:

sample 1: ['1.30', '2.50', '3.65']
sample 2: ['2.95', '0.10', '0.75']

两条样本各得到三个数,形状从 (2, 12) 变成 (2, 3)。手工核对第一条样本的第一个输出,算式是:

0.50×1.0 + 0.10×0.5 + (−0.20)×2.0 + 0.30×1.5 + 0.00×0.0 + 0.20×3.0
+ 0.40×1.0 + (−0.30)×2.5 + 0.10×0.5 + 0.60×1.0 + (−0.10)×2.0 + 0.20×0.0
= 0.50 + 0.05 − 0.40 + 0.45 + 0.00 + 0.60 + 0.40 − 0.75 + 0.05 + 0.60 − 0.20 + 0.00
= 1.30

矩阵乘法的计算量是「输出维数 × 输入维数 × 样本数」。12×3×2 只有 72 次乘加,看起来很小;换成 10000 维输入、1000 维输出、256 条 batch,一次前向就是 25.6 亿次乘加。形状不变的时候感觉不到成本,形状一大,成本就变成了显存和延迟的主要来源。

把矩阵当函数看:每个输出是一个点积

把矩阵看成函数,会清楚很多。函数 f 接收一个 n 维向量,返回一个 m 维向量,写成 f(x) = Wx。输出的第 i 个分量,就是 W 的第 i 行与 x 的点积(dot product):对应分量相乘,再全部相加,结果是一个数。

用 2×3 矩阵手算一遍。取 W 为两行三列,输入 x 为 (1, 2, 3):

     [ 2  −1   3 ]        [ 1 ]
W =  [           ]   x =  [ 2 ]
     [ 0   4   1 ]        [ 3 ]

y1 = 2×1 + (−1)×2 + 3×3 = 2 − 2 + 9 = 9
y2 = 0×1 + 4×2 + 1×3 = 0 + 8 + 3 = 11

用代码验证:

M = [[2, -1, 3], [0, 4, 1]]
x = [1, 2, 3]
print(["%d" % sum(a * b for a, b in zip(row, x)) for row in M])
['9', '11']

这里没有任何 x1*x2 这样的交叉项,每个输出都是输入的加权和,这就是「线性」的含义。矩阵能表达的只有这种关系;遇到「两个特征同时为大才触发」的规则,单靠矩阵不够,需要非线性激活,或者人工构造交叉特征再送进来。

实际的一层通常是 y = Wx + b,b 是长度为 m 的向量,每个输出配一个偏置。加上 b 之后仍然被叫作线性层,因为 b 只是把结果整体平移,没有引入输入之间的乘积;严格说它是仿射变换,工程里习惯仍归到线性这一类。偏置的作用是让输出不必经过原点,分类边界因此可以偏移。

读一个矩阵时,可以按行读,也可以按列读。按行读是在问「每个输出由哪些输入组合而成」;按列读是在问「每个输入会影响到哪些输出」。两种读法都成立,前者适合看权重,后者适合看几何,下一篇会重点用后者。

张量只是再多几个维度

张量(tensor)是矩阵往高维的推广,通俗说就是多维数组。形状(shape)是一个元组,依次写出每一维的长度。标量可以看成 0 维张量,向量是一维,矩阵是二维,再往上就是三维、四维。

图像批次常见的形状是 (B, C, H, W)。B 是 batch 大小,表示一次处理多少张图;C 是通道数,RGB 图是 3;H 和 W 是高和宽。四个字母的顺序不是数学规定,是框架约定:PyTorch 默认通道在前,TensorFlow 的不少接口默认通道在后。读别人的代码时先确认这一点,否则同样的 reshape 会得到完全不同的图。

embedding 表就是一个二维张量:10000 行词表,每行 128 维。算内存时先算元素个数,再乘每个元素的字节数:

n = 10000 * 128
b32 = n * 4
b64 = n * 8
print("params", n)
print("fp32 bytes", b32, "MiB", "%.2f" % (b32 / 1024 / 1024), "MB", "%.2f" % (b32 / 1000 / 1000))
print("fp64 bytes", b64, "MiB", "%.2f" % (b64 / 1024 / 1024), "MB", "%.2f" % (b64 / 1000 / 1000))
print("ratio", b64 / b32)
print("adam 5 copies fp32 MiB", "%.2f" % (b32 * 5 / 1024 / 1024))
params 1280000
fp32 bytes 5120000 MiB 4.88 MB 5.12
fp64 bytes 10240000 MiB 9.77 MB 10.24
ratio 2.0
adam 5 copies fp32 MiB 24.41

1,280,000 个参数,float32 每个 4 字节,共 5,120,000 字节,按 1024 换算是 4.88 MiB,按十进制叫 5.12 MB。同一张表换成 float64,每个 8 字节,立刻变成 9.77 MiB。只换精度这一项,就差 2 倍。

只算参数

10000×128 个 float32,约 5.12 MB。这是推理时最小的一份,也是「模型多大」最常被引用的数字。

算上训练状态

Adam 还要存梯度、一阶动量、二阶动量和一份主权重,加上参数本身常见是 5 份,约 24.41 MiB。训练显存的大头通常在这里。

「差了 4 倍」的估算,往往是两个人数的东西不一样:一边只算 float32 的一份参数,另一边按 float64 把参数和梯度各算一份,5.12 乘 2 乘 2 正好约 20 MB;再把 MB 和 MiB 混用,数字还会再飘一点。只报一个总数,无法判断谁对谁错。讨论内存必须把三件事说全:元素个数、每个元素几个字节、要存几份。

还有一层容易忽略:张量在内存里通常是一条连续的一维缓冲区,形状只是在这条缓冲区上切分的视图。改变形状可能不复制数据,只换一套下标换算规则;转置通常只是改步长(stride),也不一定真的搬运。判断一次操作贵不贵,要看它有没有产生新的内存,而不是看形状变了多少。反过来,reshape 在某些布局下必须复制,代价就不一样了。

形状对不上怎么排查

形状对不上是线性代数在工程里最高频的错误。先记住广播(broadcasting)的两条规则:从最右边一维开始对齐;每一维要么两边相等,要么其中一边是 1,否则报错。

(100, 12) 加 (12,) 能成立:偏置被看成 (1, 12),再沿 batch 维复制 100 份。它的意思是每个特征一个偏置,所有样本共用。这也正是全连接层偏置的标准形状。

(100, 12) 加 (100,) 不成立:右对齐之后,12 和 100 对不上。写代码的人常常想「每个样本一个偏置」,但那是 (100, 1),语义和 (12,) 完全不同。

(100, 12) 和 (100, 1) 也能算,结果是每一列都加上同一个按样本变化的数。它不会报错,但含义是「每个样本一个偏置」,和「每个特征一个偏置」完全是两件事。看到形状里有 1,先问这个 1 是有意留下的还是顺手写出来的。

用纯 Python 模拟这两条规则:

def bcast(a, b):
    ra, rb = len(a), len(b)
    n = max(ra, rb)
    pa = (1,) * (n - ra) + tuple(a)
    pb = (1,) * (n - rb) + tuple(b)
    out = []
    for i in range(n):
        if pa[i] == pb[i]:
            out.append(pa[i])
        elif pa[i] == 1:
            out.append(pb[i])
        elif pb[i] == 1:
            out.append(pa[i])
        else:
            raise ValueError("shape mismatch %s vs %s at axis %d" % (a, b, i - n))
    return tuple(out)

print(bcast((100, 12), (12,)))
try:
    print(bcast((100, 12), (100,)))
except ValueError as e:
    print("ValueError:", e)
(100, 12)
ValueError: shape mismatch (100, 12) vs (100,) at axis -1

排查顺序建议固定成四步。第一步,把参与运算的每个张量 shape 打印出来,不要凭记忆。第二步,看内维:矩阵乘法要求左边最后一维等于右边倒数第二维,也就是 (m, n) 乘 (n, p)。第三步,看 batch 维是否被当成特征,比如把 (100, 12) 转置成 (12, 100) 再乘,形状能过,含义全错。第四步,检查是不是少了一次转置,或者多了 keepdims 留下的长度 1 的维度。

广播会把错误静默地算出一个结果。两个形状里恰好有 1 时,不会报错,只会复制,结果可能完全不对。凡是形状里出现 1,都要停下来确认它是不是你想要的,而不是庆幸代码跑通了。

参数量怎么估

参数量可以直接数。一个全连接层,输入 n 维、输出 m 维,权重是 n×m 个,偏置 m 个,合计 nm + m。偏置不能省掉,因为它是每个输出一个,不是所有输出共用一个。

def fc(i, o):
    return i * o + o

print("12->3:", fc(12, 3))
n1 = fc(12, 8)
n2 = fc(8, 3)
print("12->8:", n1, "8->3:", n2, "total:", n1 + n2)
total = n1 + n2
print("fp32 bytes:", total * 4)
print("adam bytes:", total * 4 * 5)
print("big layer 4096x4096:", 4096 * 4096,
      "fp32 MiB", "%.1f" % (4096 * 4096 * 4 / 1024 / 1024),
      "adam MiB", "%.1f" % (4096 * 4096 * 4 * 5 / 1024 / 1024))
12->3: 39
12->8: 104 8->3: 27 total: 131
fp32 bytes: 524
adam bytes: 2620
big layer 4096x4096: 16777216 fp32 MiB 64.0 adam MiB 320.0

12 维到 3 维是 12×3+3=39 个参数。两层小网络,12 维进、8 维隐藏、3 维输出:第一层 12×8+8=104,第二层 8×3+3=27,总共 131 个。float32 只占 524 字节,训练状态约 2620 字节。这个规模小到可以忽略,但它把公式固定下来了,扩到真实模型只是把数字换大。

估算时还有一处容易漏:输入层本身没有参数,但它的维度决定了第一层的权重数量;输出层如果接分类头,要单独再算。逐层把「输入维数 × 输出维数 + 输出维数」列出来再加总,比凭感觉报一个数量级可靠。

模型大小和显存不是一回事。参数只占一份,训练还要梯度、优化器状态和每层的激活值。一个 4096×4096 的方阵有 16,777,216 个参数,float32 占 64 MiB,Adam 五份就是 320 MiB;batch 一大,激活值还会继续涨。部署时只做推理,通常只留参数和少量临时缓冲,账又小回去。

所以「模型 7B」说的是参数量,「显存 80G」说的是峰值占用,中间隔着精度、份数、batch 大小、序列长度这几层换算。拿参数量直接除显存,得到的数字只能当下限,不能当预算。

一张现象对照表

下面这些现象在项目里反复出现,原因各不相同,但都能回到向量、矩阵的形状和约定上。

现象真实原因第一步查什么
矩阵乘法报维度错内维不相等,左边列数和右边行数对不上打印两边的 shape,确认 (m, n) 乘 (n, p)
输出形状多了一维用了 keepdims,或把 (n,) 和 (1, n) 混着传打印每一步的 shape,找出长度 1 是从哪来的
batch 维被当成特征转置顺序错了,把样本数放到了特征维确认第一维是不是样本数,再检查转置位置
参数表内存估算差几倍只算了一份参数,没算精度、梯度、优化器状态重算 元素个数 × 字节数 × 份数
偏置加不进去偏置形状和输出的最后一维不匹配先看最后一维,偏置应是 (n,) 或 (1, n)
把行向量和列向量搞反乘法方向错了,或者库对一维形状有自己的解释显式写成 (1, n) 或 (n, 1),再乘一次
显存够但跑不起来中间激活和临时张量比参数大,峰值出现在前向按 batch 打印每层输出的 shape 和元素数

边界与代价

第一,矩阵只描述线性关系。它能做加权求和,不能表达「两个条件同时成立才为真」这类逻辑。加偏置只是把直线平移,仍然没有离开线性。要做非线性,必须在两层之间插入激活函数,或者手工构造交叉特征。

第二,形状约定因库而异。同一个四维张量,通道在前和在后的解释完全不同;同一个一维数组,有的库当行向量,有的库当列向量。跨框架搬代码时,先对齐约定再谈结果,否则错误会藏在「能跑」的表象里。

第三,广播让错误静默通过。这是便利也是风险:能自动补齐维度,也会把 (100, 12) 和 (12,) 之外的一些组合默默算完。凡是形状里出现 1,都要人工确认一次。

第四,内存是主要成本。参数本身按元素数线性增长,但训练时的梯度、优化器状态、激活值会成倍放大;矩阵乘法在超过缓存后还会受内存带宽限制,算力表上的数字不一定跑得出来。大模型的第一道瓶颈通常是显存,不是浮点运算。

第五,浮点结果不是精确的。大量数相加时,顺序会影响最后几位;float32 的有效位数有限,累加几百万项可能丢精度。矩阵乘法的实现通常调用底层库,分块和并行会改变求和顺序,所以同一份输入在不同设备上可能有微小差异。

第六,矩阵乘法的耗时随形状增长得很快。两个 n×n 矩阵相乘是 n 的三次方级,n 翻一倍,乘加次数变成八倍。实际实现会分块、并行、用专用指令,但量级不会因此消失;把一个大矩阵拆成两个小矩阵相乘,往往能同时省下计算和内存。

当天可以验证的练习

这五条都能在本机用标准库完成,不需要装任何框架。

  1. 手写一个 2×3 矩阵乘 3 维向量的函数,输入用文中那组数,算出 9 和 11,再用列表推导式写的点积版本对照,确认两种写法结果一致。
  2. 算 10000×128 的 embedding 表在 float32 和 float64 下各占多少字节、多少 MiB,再按 5 份训练状态重算一遍,比较和只算参数差几倍。
  3. 先构造 (100, 12) 加 (100,) 的广播检查,让它抛出错误;再把偏置改成 (12,),确认结果是 (100, 12),并解释复制发生在哪一维。
  4. 算 12 维到 8 维、8 维到 3 维两层的参数量,再算 12 维直接到 3 维的参数量,比较两者差多少,说明隐藏层把参数花在了哪里。
  5. 打印一个图像 batch、一个 embedding 表、一个偏置向量的 shape,逐个说出每个数字的含义,再指出哪些位置可以广播、哪些会报错。

小结

这篇可以压成三句。向量是一串有序的数,维度是分量个数,顺序和约定都参与含义;矩阵是批量执行的点积,形状 (m, n) 表示 n 维进、m 维出;张量只是多了几维,内存问题都能还原成元素个数、字节数和份数。

下一篇讲矩阵乘法的几何含义。这一篇把矩阵当成一组权重,下一篇换一个视角:矩阵的每一列,其实是基向量被送到的新位置;乘法规则不是随便规定的,它正好对应一次空间变换。理解这一点,旋转、缩放、投影,以及后面讲到的秩与可逆,才有统一的解释。