w wyl123ly 的博客
MD

NumPy向量化

19 KB 2026.10.18 原文件

NumPy向量化

定义

NumPy 向量化指以作用于整个 ndarray 的原语(ufunc、广播、归约、索引)替代 Python 层逐元素循环,使循环下沉到编译内核并按连续内存访问。

  • ndarray:固定元素数、同质 dtype 的多维数组对象,由数据缓冲区与元数据(shape、strides、dtype、offset)描述。
  • 轴(axis):维度编号,从 0 开始;axis=k 的归约消除第 轴。
  • shape:各轴长度组成的元组,其长度即 ndim。
  • dtype:元素类型与字节宽度,float32 每元素 4 字节。
  • itemsize:单个元素的字节数;nbytes = size × itemsize。
  • strides:沿某轴前进一个索引所需的字节数。
  • C 序(C order,行优先):最后一轴步长等于 itemsize;F 序(Fortran order,列优先):第一轴步长等于 itemsize。
  • 视图(view):与原数组共享数据缓冲区的新数组对象,仅修改 shape、strides 与 offset。
  • 副本(copy):拥有独立缓冲区的数组。
  • 广播(broadcasting):形状不同的数组按规则虚拟扩展,不实际复制元素。
  • ufunc:对数组逐元素运算的编译函数,支持 dtype 分派、广播与 out 参数。
  • 、:第 轴的索引与字节步长; 为轴数。

为什么重要

  1. 语义同源。PyTorch 的 shape、stride 与广播规则与 NumPy 一致,先在本篇固定语义,后续 PyTorch实战入门 只需替换设备与自动求导。
  2. 常数因子。10^6 规模的逐元素运算,Python 循环约 80 ms,向量化约 5 ms(第 11 节实测),训练循环每一步都放大该差异。
  3. 视图与副本混淆属于静默错误。对视图赋值会改写原数组,对副本赋值没有效果;reshape 在非连续数组上隐式复制,语义与性能同时改变。
  4. 广播错误产生形状错误。(B, T, D) 与 (B, D) 不能直接相减,必须写成 b[:, None, :],错误在运行时才暴露。
  5. dtype 决定显存。float64 的字节数是 float32 的两倍,GPU 上 float64 的吞吐远低于 float32。
  6. 可复现性。np.random.seed 修改全局状态,default_rng 返回独立生成器,并行数据加载必须为每个 worker 派生独立流。

原理与推导

以下各节代码块在同一命名空间中按顺序执行,命名空间开头已执行 import numpy as np(NumPy 2.3.5);每个块的输出注释对应该块运行后的结果。

1 ndarray 的内存布局

ndarray 由一段连续或带步长的一维缓冲区与元数据组成;第 轴索引为 的元素地址为

C 序要求 且 ;F 序要求 且 。转置只反转 strides,不移动数据,因此 C 序数组转置后成为 F 序。广播把长度为 1 的轴的步长置为 0,使同一地址被逻辑上重复索引。

对象(float64,原 shape (3, 4))shapestrides(字节)共享缓冲区
a(3, 4)(32, 8)是(自身)
a.T(4, 3)(8, 32)是
a.reshape(2, 6)(2, 6)(48, 8)是
a[:, ::2](3, 2)(32, 16)是
a.ravel()(12,)(8,)是
a.flatten()(12,)(8,)否
a = np.arange(12, dtype=np.float64).reshape(3, 4)
print(a.shape, a.dtype, a.strides, a.nbytes)     # 输出: (3, 4) float64 (32, 8) 96
b = a.T
print(b.shape, b.strides, b.flags["F_CONTIGUOUS"])  # 输出: (4, 3) (8, 32) True
c = a[:, ::2]
print(c.shape, c.strides)                        # 输出: (3, 2) (32, 16)

2 创建、dtype 与类型转换

np.array、np.zeros、np.ones、np.full、np.arange、np.linspace、np.empty 构造数组;np.array 依输入推断 dtype,NumPy 2.x 在 Windows 上也默认 int64(1.x 为 int32)。astype 默认返回副本,把浮点转整数时截断小数;np.asarray 在 dtype 与布局匹配时返回原对象。

a = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.float32)
print(a.shape, a.dtype, a.itemsize, a.nbytes)   # 输出: (2, 3) float32 4 24
b, c = np.asarray(a), a.astype(np.float64)
print(b is a, c is a)                           # 输出: True False
print(np.arange(6).reshape(2, 3).tolist())      # 输出: [[0, 1, 2], [3, 4, 5]]
print(np.linspace(0, 1, 5))                     # 输出: [0.   0.25 0.5  0.75 1.  ]
print(np.array([1, 2]).dtype)                   # 输出: int64(NumPy 2.x)
print(float(np.float32(0.1)) == 0.1)            # 输出: False

3 索引与赋值

基础索引与切片返回视图,布尔掩码与整数数组索引返回副本。多个整数数组按广播规则配对:a[[0, 1], [1, 2]] 取 (0,1) 与 (1,2) 两个元素。多个花式索引被切片分隔时,结果把花式索引的轴前置,例如 a[[0, 1], :, [0, 2]] 的形状为 (2, 3);需要外积语义时用 np.ix_。a[idx] += 1 的语义是先 gather、再运算、最后 scatter,重复索引只有最后一次写入生效;要逐次累加必须用 np.add.at。

a = np.arange(12).reshape(3, 4)
print(a[1, 2], a[0])                    # 输出: 6 [0 1 2 3]
print(a[:, 1:3].shape)                  # 输出: (3, 2)
print(a[a % 2 == 0])                    # 输出: [ 0  2  4  6  8 10]
print(a[[0, 1, 2], [1, 2, 3]])          # 输出: [ 1  6 11]
b = a[:, 1:3]; b[:] = -1                # 通过视图写入
print(a[0])                             # 输出: [ 0 -1 -1  3]
idx = np.array([0, 0, 1]); c = np.zeros(3, dtype=int)
c[idx] += 1
print(c)                                # 输出: [1 1 0](重复索引只写一次)
np.add.at(c, idx, 1)
print(c)                                # 输出: [3 2 0](重复索引逐次累加)

4 视图与副本

reshape 在不复制数据即可满足新形状时返回视图,否则返回副本;transpose、T、swapaxes 总是视图;ravel 优先返回视图,必要时复制;flatten 总是复制。判断依据是 np.shares_memory 与 .base,不能只看 shape。

a = np.arange(12).reshape(3, 4)
print(np.shares_memory(a, a.T), np.shares_memory(a, a.reshape(2, 6)))
# 输出: True True
print(np.shares_memory(a, a.ravel()), np.shares_memory(a, a.flatten()))
# 输出: True False
print(np.shares_memory(a, a[:, ::2]), np.shares_memory(a, a[[0, 2]]))
# 输出: True False
print(a.flatten().base is None)          # 输出: True(副本拥有独立缓冲区)

5 广播规则

规则共四条:形状不同时在短形状左侧补 1;逐轴比较,相等或其中之一为 1 则兼容;输出形状取各轴最大值;不实际复制,扩展轴的步长置 0。

例 1(标量):X(2,3) + 1.0。标量 shape 为 (),左侧补 1 后为 (1,1);两轴均兼容,输出 (2,3),语义是每个元素加同一常数。

例 2(偏置):X(2,3) + b(3,)。b 补 1 得 (1,3);轴 0 上 2 与 1 兼容取 2,轴 1 上 3 与 3 相等取 3,输出 (2,3),语义是每行加同一向量。

例 3(位置编码):Y(B,T,D) + pos(T,D)。pos 补 1 得 (1,T,D);三轴分别扩展为 B、T、D,输出 (B,T,D),语义是所有样本共用同一位置表。

失败例:Y(B,T,D) - z(B,D)。对齐后 z 为 (1,B,D),轴 -2 上 T 与 B 既不相等也非 1,抛 ValueError。

X = np.arange(6).reshape(2, 3)           # (2, 3)
b = np.array([10, 20, 30])               # (3,)
print((X + b).shape, (X + b)[0])         # 输出: (2, 3) [10 21 32]

Y = np.arange(24).reshape(2, 3, 4)       # (B, T, D)
pos = np.arange(12).reshape(3, 4)        # (T, D)
print((Y + pos).shape)                   # 输出: (2, 3, 4)

u, v = np.array([1, 2, 3]), np.array([10, 20, 30, 40])
print((u[:, None] * v[None, :]).shape)   # 输出: (3, 4)

try:
    Y - np.zeros((2, 4))                 # (1, 2, 4) 与 (2, 3, 4) 冲突
except ValueError as e:
    print("ValueError:", str(e).split(" with ")[0])
# 输出: ValueError: operands could not be broadcast together

6 ufunc 与聚合 axis

ufunc 逐元素施加运算,接受 out、where、dtype 参数,因此可以复用输出缓冲区避免临时数组。归约函数把 axis 指定的轴消除:axis=0 沿行方向压缩、保留列数;axis=(0, 1) 同时消除两轴;keepdims=True 保留长度为 1 的轴,使结果能按广播规则写回原形状。softmax 沿最后一轴先减最大值再取指数,避免 exp 溢出。

x = np.arange(12, dtype=np.float32).reshape(3, 4)
print(x.sum(axis=0), x.sum(axis=1))          # 输出: [12. 15. 18. 21.] [ 6. 22. 38.]
print(x.sum(axis=1, keepdims=True).shape)    # 输出: (3, 1)
print(x.mean(), x.argmax(axis=0))            # 输出: 5.5 [2 2 2 2]

logits = np.array([[1.0, 2.0, 3.0]])
z = logits - logits.max(axis=-1, keepdims=True)
p = np.exp(z) / np.exp(z).sum(axis=-1, keepdims=True)
print(p.round(4), p.sum(axis=-1))            # 输出: [[0.09   0.2447 0.6652]] [1.]

7 矩阵乘法 @ 与 np.dot

表达式语义高维行为
a @ b、np.matmul矩阵乘最后两维相乘,前导维按广播规则
np.dot(a, b)点积2D 时等价;高维时 的最后一轴与 的倒数第二轴求和,不广播
np.inner(a, b)内积最后一轴求和
a * b逐元素乘按广播规则
A, B = np.arange(6).reshape(2, 3), np.arange(12).reshape(3, 4)
print((A @ B).shape, np.dot(A, B).shape)     # 输出: (2, 4) (2, 4)
ba, bb = np.ones((5, 2, 3)), np.ones((5, 3, 4))
print((ba @ bb).shape)                       # 输出: (5, 2, 4)
print(np.dot(ba, bb).shape)                  # 输出: (5, 2, 5, 4)

批量矩阵乘必须用 @ 或 np.matmul;np.dot 在 3D 输入下把 的最后一轴与 的倒数第二轴配对,同时保留 的前导轴与 的最后一轴,结果形状不是逐样本矩阵乘。

8 einsum 与注意力打分

einsum 用下标字符串描述求和约定:出现在输出中的下标保留,未出现的下标求和,... 表示参与广播的前导维。optimize=True 让 NumPy 选择收缩顺序并在合适处调用 BLAS,避免生成巨大中间张量。

A = np.arange(6).reshape(2, 3)
print(np.einsum("ij->ji", A).shape)      # 输出: (3, 2),等价于转置
print(np.einsum("ij->j", A))             # 输出: [3 5 7],列求和

rng = np.random.default_rng(0)
B, H, T, D = 2, 3, 4, 8
Q = rng.standard_normal((B, H, T, D), dtype=np.float32)
K = rng.standard_normal((B, H, T, D), dtype=np.float32)
scores = np.einsum("bhtd,bhsd->bhts", Q, K) / D ** 0.5
print(scores.shape, scores.dtype)        # 输出: (2, 3, 4, 4) float32
ref = Q @ K.swapaxes(-1, -2) / D ** 0.5
print(np.allclose(scores, ref))          # 输出: True

除以 D ** 0.5 而不是 np.sqrt(D):前者是 Python 浮点数,按 NEP 50 的弱标量规则不提升 float32;后者是 NumPy 标量,会把结果提升为 float64。

9 随机数 Generator 与可复现性

np.random.default_rng(seed) 返回独立的 Generator(位生成器 PCG64),不读写全局状态;同 seed、同调用序列、同 NumPy 版本给出同一结果。SeedSequence.spawn(n) 从同一熵源派生互不相同的子序列,适合为多个数据加载 worker 分配种子。

rng1, rng2 = np.random.default_rng(42), np.random.default_rng(42)
print(np.array_equal(rng1.random(3), rng2.random(3)))   # 输出: True

ss = np.random.SeedSequence(42)
g1, g2 = (np.random.default_rng(c) for c in ss.spawn(2))
print(np.array_equal(g1.integers(0, 100, 2), g2.integers(0, 100, 2)))
# 输出: False(同一 SeedSequence 派生的两条流互不相同)

g = np.random.default_rng(0)
print(np.array_equal(g.permutation(5), np.random.default_rng(0).permutation(5)))
# 输出: True(同 seed 与同调用序列给出同一排列)

10 dtype 与内存

nbytes = size × itemsize,因此同一形状下 float64 占 float32 的两倍内存。float32 的机器 epsilon 为 ,约 7 位十进制有效数字;float64 为 ,约 16 位。混合 dtype 的运算按 result_type 提升,但 NEP 50 规定 Python 标量是弱类型,不改变数组 dtype。

for dt in (np.float16, np.float32, np.float64):
    a = np.ones(10 ** 6, dtype=dt)
    print(dt.__name__, f"{a.nbytes / 2 ** 20:.2f} MiB")
# 输出: float16 1.91 MiB / float32 3.81 MiB / float64 7.63 MiB

print(np.finfo(np.float32).eps, np.finfo(np.float64).eps)
# 输出: 1.1920929e-07 2.220446049250313e-16
print(np.result_type(np.float32, np.float64))     # 输出: float64
print((np.ones(3, np.float32) + 1.0).dtype)       # 输出: float32(NEP 50 弱标量)

11 向量化性能

向量化的收益来自解释器开销的消除:Python 每次迭代执行字节码并创建对象,NumPy 把同一运算交给编译循环与 SIMD 指令,单元素开销从数十纳秒降到数纳秒。代价是临时数组:a * b + 1.0 会分配两个与 a 同尺寸的中间数组,可用 np.add(..., out=...) 复用缓冲区。小数组(数千元素以下)时调用开销占主导,向量化未必更快。

import timeit

n = 10 ** 6
a = np.arange(n, dtype=np.float64); b = np.ones(n)
t_np = min(timeit.repeat(lambda: a * b + 1.0, number=10, repeat=3)) / 10
xs, ys = a.tolist(), b.tolist()
t_py = min(timeit.repeat(lambda: [x * y + 1.0 for x, y in zip(xs, ys)],
                         number=10, repeat=3)) / 10
print(f"numpy {t_np*1e3:.2f} ms, python {t_py*1e3:.2f} ms, 比值 {t_py/t_np:.0f}x")
# 输出: numpy 约 5 ms,python 约 80 ms,比值 10–20x(量级随机器变化)

关键直觉

两个判断依据

广播不复制数据:长度为 1 的轴其步长被置 0,同一地址被逻辑上重复索引,运算仍只读写原始元素一次。视图与副本的差别在于是否共享缓冲区,判断依据是 np.shares_memory 与 .base,不是 shape,也不是是否转置。两条结论都直接来自第 1 节的地址公式:只改 strides 即可改变逻辑形状而不移动数据。

例子与代码

下面的程序实现带因果掩码的多头注意力打分:einsum 完成批量内积,布尔掩码经广播写入 -inf,softmax 归一化后再与 V 收缩。运行环境为 NumPy 2.3,float32。

import numpy as np

def softmax(x, axis=-1):
    x = x - x.max(axis=axis, keepdims=True)   # 减去最大值,避免 exp 溢出
    e = np.exp(x)
    return e / e.sum(axis=axis, keepdims=True)

rng = np.random.default_rng(0)
B, H, T, D = 2, 2, 4, 8
Q = rng.standard_normal((B, H, T, D), dtype=np.float32)
K = rng.standard_normal((B, H, T, D), dtype=np.float32)
V = rng.standard_normal((B, H, T, D), dtype=np.float32)

scores = np.einsum("bhtd,bhsd->bhts", Q, K) / D ** 0.5     # (B, H, T, T)
mask = np.triu(np.ones((T, T), dtype=bool), k=1)           # 上三角为 True
scores = np.where(mask, -np.inf, scores)                   # 广播到 (B, H, T, T)
attn = softmax(scores, axis=-1)
out = np.einsum("bhts,bhsd->bhtd", attn, V)                # (B, H, T, D)

print(scores.shape, attn.shape, out.shape)   # 输出: (2, 2, 4, 4) (2, 2, 4, 4) (2, 2, 4, 8)
print(bool(np.isfinite(attn).all()), attn[..., 0, :].sum(-1).ravel())
# 输出: True [1. 1. 1. 1.](每个 (batch, head) 组合的第一位只能看到自己,权重为 1)

def scores_loop(q, k):
    b_, h_, t_, d_ = q.shape
    s = np.empty((b_, h_, t_, t_), dtype=q.dtype)
    for bi in range(b_):
        for hi in range(h_):
            for i in range(t_):
                for j in range(t_):
                    s[bi, hi, i, j] = q[bi, hi, i] @ k[bi, hi, j]
    return s / d_ ** 0.5

print(np.allclose(scores_loop(Q, K), Q @ K.swapaxes(-1, -2) / D ** 0.5, atol=1e-5))
# 输出: True

这段代码在做什么:einsum 在 (B, H, T, D) 与 (B, H, T, D) 上对 d 求和,得到 (B, H, T, T) 的成对打分;np.triu 生成 (T, T) 掩码,经广播作用到四个轴;softmax 沿最后一轴归一化,第二个 einsum 用权重对 V 加权求和。为什么这样写:全程没有逐样本的 Python 循环,中间张量只有打分矩阵及其掩码版本,形状在每一步都可核对。去掉掩码后,第 0 个位置会读到未来 token,训练损失异常偏低而验证生成不自洽;去掉 keepdims=True 后,x.max(axis=-1) 的形状为 (B, H, T),无法与 (B, H, T, T) 广播,减法直接报错。

易错点

WARNING

- a.T、a[:, ::2] 与可视图化的 reshape 返回视图,a0, 2、布尔索引、flatten() 返回副本;对前者赋值改写原数组,对后者赋值只改临时对象。

- 广播从尾部对齐:(B, T, D) 与 (B, D) 不兼容(轴 -2 上 T 与 B 冲突),必须写成 b[:, None, :]。

- np.dot 在高维下按「最后一轴 × 倒数第二轴」求和且不广播,批量矩阵乘必须用 @ 或 np.matmul。

- np.empty 不初始化,内容为内存残留,依赖其初值属于未定义行为。

- astype 截断小数而不是四舍五入,且默认返回副本;np.asarray 仅在 dtype 与布局匹配时避免复制。

- s[idx] += 1 对重复索引只写一次,需要逐次累加时用 np.add.at;np.random.seed 修改全局状态,并行 worker 必须各自派生种子。

关联笔记

  • 前置:Python语法速查 —— 名字绑定、切片与迭代器协议是理解视图与花式索引的前提。
  • 前置:线性代数 —— 矩阵乘法、转置与维度的符号约定在此定义。
  • 后续:Pandas数据清洗 —— 布尔索引与对齐在带标签数据上扩展为 index 与 columns 语义。
  • 后续:PyTorch实战入门 —— torch.Tensor 复用 shape、stride 与广播规则,并增加设备与自动求导。
  • 应用:注意力机制与QKV —— 缩放点积注意力即本篇 einsum 例子的批量版本。

达标检测

  • [ ] 手算 np.arange(12, dtype=np.float64).reshape(3, 4) 的 strides,并解释 a.T 的 strides 为何是 (8, 32)。
  • [ ] 对 (B,T,D) 与 (T,D)、(B,D) 两组运算分别写出对齐后的形状,指出哪一组抛 ValueError 及原因。
  • [ ] 写出 Y = X @ W + b 的形状推导,并说明 3D 输入下 np.dot(X, W) 与 X @ W 的结果差异。
  • [ ] 用 einsum 写出缩放点积注意力打分,并用四重循环版本验证 allclose。
  • [ ] 用 timeit 比较 10^6 规模下逐元素 Python 循环与向量化,报告量级比并解释差距来源。
  • [ ] 计算 (1024, 1024) 的 float32 与 float64 数组的 nbytes,说明混合精度训练为何保留 float32 主权重。

参考来源

  • NumPy 官方文档, Broadcasting —— 对应第 5 节的四条规则与四个形状推导。
  • NumPy 官方文档, The N-dimensional array (ndarray) 与 NumPy internals —— 对应第 1、4 节的 strides、连续性与视图判定。
  • NumPy 官方文档, numpy.einsum、numpy.matmul、numpy.dot —— 对应第 7、8 节的语义对比与注意力打分。
  • NumPy 官方文档, Random Generator 与 NEP 50 —— 对应第 9、10 节的生成器隔离与 dtype 提升规则。
  • d2l.ai《动手学深度学习》, "数据操作" 与 "线性代数" 节 —— 对应创建、索引、广播与矩阵乘法示例。