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参数。 - 、:第 轴的索引与字节步长; 为轴数。
为什么重要
- 语义同源。PyTorch 的 shape、stride 与广播规则与 NumPy 一致,先在本篇固定语义,后续 PyTorch实战入门 只需替换设备与自动求导。
- 常数因子。10^6 规模的逐元素运算,Python 循环约 80 ms,向量化约 5 ms(第 11 节实测),训练循环每一步都放大该差异。
- 视图与副本混淆属于静默错误。对视图赋值会改写原数组,对副本赋值没有效果;
reshape在非连续数组上隐式复制,语义与性能同时改变。 - 广播错误产生形状错误。
(B, T, D)与(B, D)不能直接相减,必须写成b[:, None, :],错误在运行时才暴露。 - dtype 决定显存。float64 的字节数是 float32 的两倍,GPU 上 float64 的吞吐远低于 float32。
- 可复现性。
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)) | shape | strides(字节) | 共享缓冲区 |
|---|---|---|---|
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《动手学深度学习》, "数据操作" 与 "线性代数" 节 —— 对应创建、索引、广播与矩阵乘法示例。