---
tags: [AI, numpy, 向量化]
阶段: 02-Python与数据处理
难度: ★★☆
created: 2026-10-18
related: "[[MOC-Python]], [[Python语法速查]], [[线性代数]], [[PyTorch实战入门]]"
---

# NumPy向量化

## 定义

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

- ndarray：固定元素数、同质 dtype 的多维数组对象，由数据缓冲区与元数据（shape、strides、dtype、offset）描述。
- 轴（axis）：维度编号，从 0 开始；`axis=k` 的归约消除第 $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` 参数。
- $i_k$、$s_k$：第 $k$ 轴的索引与字节步长；$n$ 为轴数。

## 为什么重要

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 由一段连续或带步长的一维缓冲区与元数据组成；第 $k$ 轴索引为 $i_k$ 的元素地址为

$$\mathrm{addr}(i_0,\dots,i_{n-1}) = \text{offset} + \sum_{k=0}^{n-1} i_k s_k$$

C 序要求 $s_{n-1} = \text{itemsize}$ 且 $s_k = s_{k+1}\cdot \text{shape}_{k+1}$；F 序要求 $s_0 = \text{itemsize}$ 且 $s_k = s_{k-1}\cdot \text{shape}_{k-1}$。转置只反转 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,) | 否 |

```python
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 与布局匹配时返回原对象。

```python
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`。

```python
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。

```python
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`。

```python
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` 溢出。

```python
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 时等价；高维时 $a$ 的最后一轴与 $b$ 的倒数第二轴求和，不广播 |
| `np.inner(a, b)` | 内积 | 最后一轴求和 |
| `a * b` | 逐元素乘 | 按广播规则 |

```python
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 输入下把 $a$ 的最后一轴与 $b$ 的倒数第二轴配对，同时保留 $a$ 的前导轴与 $b$ 的最后一轴，结果形状不是逐样本矩阵乘。

### 8 einsum 与注意力打分

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

```python
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 分配种子。

```python
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 为 $1.19\times10^{-7}$，约 7 位十进制有效数字；float64 为 $2.22\times10^{-16}$，约 16 位。混合 dtype 的运算按 `result_type` 提升，但 NEP 50 规定 Python 标量是弱类型，不改变数组 dtype。

```python
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=...)` 复用缓冲区。小数组（数千元素以下）时调用开销占主导，向量化未必更快。

```python
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（量级随机器变化）
```

## 关键直觉

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

## 例子与代码

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

```python
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` 返回视图，`a[[0, 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《动手学深度学习》, "数据操作" 与 "线性代数" 节 —— 对应创建、索引、广播与矩阵乘法示例。
