阅读范围、用时与原有实验记录
实验记录怎么读
本页原有耗时、内存、报错和环境值保留为原文记录;本轮内容审校未逐项复跑这些实验。版本、硬件、数据和测量方法都会影响结果,示例中的倍数也不是保证。需要复现时先核对依赖版本,再在同一输入下比较。
⏱ 50 分钟 | ⭐ 同一段数据可以有多种读法,先找起点,再按步长走。
01 / 完整解释
字节没动,说明书怎么变?
🎯 一句话
ndarray 用一套规则把下标对应到数据缓冲区中的字节。 转置和基础切片可以用不同的起点或步长读取同一块数据。改形状能否沿用原数据,要看新的读取方式。
上一章你已经知道「视图会跟着变、拷贝不会」。这一章回答为什么 —— 以及为什么有些 reshape 白拿,有些要掏钱。
⚠️ 先消歧,不然你会记混。 站内别处出现的「stride」是卷积的滑动步长(
Conv2d(stride=2),隔一格取一次)。 这一章说的 stride 是内存步长:沿某个轴走一格,地址要挪多少字节。 两者同名不同物,唯一的共同点是「跨着走」这个字面意思。
🧩 一、说明书里有什么
要找到表里的某一格,先看形状(shape)确定行列范围,再从第一个逻辑元素出发。步长(stride)表示某一轴的下标加 1 时地址变化多少字节。数据类型(dtype)决定每格怎样解读,itemsize 给出每格的字节数。
下面原有的示例以默认整数为 8 字节的环境为例。后面新增的数字练习显式指定 np.int64。
import numpy as np
base = np.arange(12)
a = base.reshape(3, 4)
print(a.shape) # (3, 4)
print(a.strides) # (32, 8) ⭐ 单位是【字节】,不是元素
print(a.itemsize) # 8 int64 每个占 8 字节
print(a.dtype) # int64
strides = (32, 8) 读作:
| 动作 | 地址挪多少 |
|---|---|
| 行号 +1(往下走一行) | 32 字节 = 4 个元素 = 一整行 |
| 列号 +1(往右走一格) | 8 字节 = 1 个元素 |
⭐ 相对起点的字节偏移 = 行号 × 行步长 + 列号 × 列步长。 偏移(offset)表示地址相差多少字节。这里的起点是 a[0, 0],行号和列号都是从 0 数的有效非负下标。比如第 2 行第 1 列,先走两行的 2 × 32 = 64 字节,再走一列的 8 字节,共 72 字节。
import numpy as np
base = np.arange(12)
a = base.reshape(3, 4)
print(a[2, 1]) # 9
off = 2 * a.strides[0] + 1 * a.strides[1] # 2*32 + 1*8
print(off) # 72 ← 字节偏移
print(off // a.itemsize) # 9 ← 第 9 个元素
print(a.ravel()[9]) # 9 ✅ 对上了
这组二维单元素索引用固定次数的乘加定位。对按行连续的 a,每 8 字节就是一格,所以 72 ÷ 8 = 9,从 0 数的第 9 格就是值 9。下面换一个读取起点,看看原来的偏移公式还怎么用。
倒着读一行,地址怎样走?
还是同一张 3×4 的表。想把每行从右往左读,可以写 v = a[:, ::-1]。第一个 : 保留所有行,第二个 ::-1 从每行最后一列开始,向左逐列取值。第一行仍是四格,起点从值 0 换到了值 3。
| 视图中的列号 | 原表中的值 | 距原表起点的字节数 |
|---|---|---|
| 0 | 3 | 24 |
| 1 | 2 | 16 |
| 2 | 1 | 8 |
| 3 | 0 | 0 |
原表每格 8 字节,所以 v[0, 0] 相对 a[0, 0] 的起点偏移是 3 × 8 = 24 字节。视图中行号加 1 仍向后走 32 字节,列号加 1 则向前走 8 字节,所以 v.strides = (32, -8)。
找 v[1, 2]。 从视图起点出发,下移一行、沿倒序列走两格,偏移是 1 × 32 + 2 × (−8) = 16 字节。再加上两个起点相差的 24 字节,得到相对原表起点的 24 + 16 = 40 字节。原表按行排列,40 ÷ 8 = 5 是从 0 数的第 5 格,也就是 a[1, 1] = 5。
import numpy as np
a = np.arange(12, dtype=np.int64).reshape(3, 4) # (3, 4)
v = a[:, ::-1] # (3, 4)
row, col = 1, 2
offset = row * v.strides[0] + col * v.strides[1]
start = v.ctypes.data - a.ctypes.data
print(v.shape, v.strides) # (3, 4) (32, -8)
print(v[0].tolist()) # [3, 2, 1, 0]
print(start, offset, start + offset) # 24 16 40
print(int(v[row, col]), int(a[1, 1])) # 5 5
print(np.shares_memory(a, v)) # True
代码中 offset 是相对视图起点的距离,start 是两个起点的地址差。.ctypes.data 在这里仅用来取得起点地址的整数值。最后两行分别验证格子取值和数据重叠。步长为负也可以共享数据。NumPy 的步长说明
🧩 二、转置为什么是免费的
既然地址是算出来的,那么把 strides 换个顺序,就等于换了一种读法:
import numpy as np
a = np.arange(12).reshape(3, 4)
print(a.shape, a.strides) # (3, 4) (32, 8)
print(a.T.shape, a.T.strides) # (4, 3) (8, 32) ⭐ 反过来了
print(np.shares_memory(a, a.T)) # True ⭐ 同一块内存
转置没有搬动任何一个字节,它只是把说明书里的 shape 和 strides 同时倒了个个儿。 原来「往下走 32 字节」,现在改成「往右走 32 字节」—— 同一块内存,换了个读法。
⭐ 这解释了一个常见困惑:为什么
a.T对 100 万行的矩阵也是瞬间返回? 因为它根本没干活。干活的是后面真正读数据的那一步。
🚦 三、⚠️ .base 不记录完整的视图链
上一章使用 np.shares_memory(a, b) 检查两数组是否有重叠内存;这一节解释为什么 .base is a 不能替代它。
import numpy as np
base = np.arange(12)
a = base.reshape(3, 4)
print(a.base is base) # True
print(a.T.base is a) # ⚠️ False —— 直觉会以为 True
print(a.T.base is base) # ⭐ True —— 它一路指回真正持有内存的那个
.base 表示该数组借用内存的来源对象,不保证是创建它时的“上一层”,也不保证一定是 ndarray。下面这组普通数组的视图链跳过了中间层;不能把这个例子的对象身份推广为所有数组的恒定规则。
⚠️ 所以上一章那个 c.base is b 的写法,只在 b 自己就是内存持有者时才成立。
一旦 b 本身也是个视图,c.base is b 就会给你 False,但它们确实共享内存。
⚠️⚠️ 而且它还会朝另一个方向骗你 —— .base 不是 None,却根本不共享内存:
import numpy as np
base = np.arange(12)
a = base.reshape(3, 4)
for name, x in [("a.T.reshape(12)", a.T.reshape(12)),
("a[1:3, [0,2]]", a[1:3, [0,2]]),
("a[[0,2]]", a[[0,2]])]:
print(f"{name:18} .base is None = {x.base is None:<5} 共享内存 = {np.shares_memory(a, x)}")
# a.T.reshape(12) .base is None = False 共享内存 = False ⚠️
# a[1:3, [0,2]] .base is None = False 共享内存 = False ⚠️
# a[[0,2]] .base is None = True 共享内存 = False
前两个明明是拷贝,.base 却不是 None —— 因为求值过程中产生了一个中间临时数组,
拷贝结果挂在那个临时数组上,而那个临时数组和 a 无关。
.base 说明当前数组是否借用其他对象的缓冲区;它不直接回答“是否与指定的 a 共享内存”。对两个具体数组使用 np.shares_memory(a, b);复杂 stride 的精确检测可能很昂贵,可设置工作上限,保守判断则用 np.may_share_memory。参见 base 与 shares_memory 文档。
⭐ 稳妥的判据永远是这个:
import numpy as np
base = np.arange(12)
a = base.reshape(3, 4)
print(np.shares_memory(a, a.T)) # True ⭐ 这个不会被中间层骗到
⚠️
np.shares_memory默认做的是精确判断,对巨大数组可能偏慢; 赶时间可以用np.may_share_memory(保守估计,可能误报「共享」但不会漏报)。
02 / 完整解释
新形状能否由 stride 表达?
🧩 四、C 序和 F 序:同一张表,两种铺法
同样一个 2×3 的表,在内存里可以按行铺,也可以按列铺:
import numpy as np
c = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int8)
f = np.asfortranarray(c)
print(np.array_equal(c, f)) # True 内容完全一样
print(c.strides, list(c.tobytes("A"))) # (3, 1) [1, 2, 3, 4, 5, 6]
print(f.strides, list(f.tobytes("A"))) # (1, 2) [1, 4, 2, 5, 3, 6]
| strides | 内存里的顺序 | 谁在用 | |
|---|---|---|---|
| C 序(行优先,NumPy 默认) | (3, 1) |
1 2 3 4 5 6 |
C、Python、PyTorch |
| F 序(列优先) | (1, 2) |
1 4 2 5 3 6 |
Fortran、MATLAB、R、BLAS 内部 |
⚠️ 用 dtype=np.int8 是为了让 tobytes 看得清。换成默认的 int64,每个数占 8 字节、前 7 个都是 0,你会看到一串没有区别的零 —— 这也是我第一次跑这个例子时踩的坑。
⭐ 你平时不需要关心序,除非:把数组交给某个 Fortran 血统的库(SciPy 的部分 LAPACK 封装),或者你发现某个操作莫名其妙慢了一截(见第六节)。
🧩 五、reshape 什么时候白拿,什么时候掏钱
先确认新形状的元素总数和原来相同,再检查指定的下标顺序能否用新的步长在原缓冲区读出。下面讲的是默认允许按需复制的 reshape。
- 能 → 返回视图,原数据无需搬动。
- 不能 → 复制数据,再按新形状返回。
import numpy as np
a = np.arange(12).reshape(3, 4)
r1 = a.reshape(4, 3)
print(np.shares_memory(a, r1)) # True ⭐ 白拿
r2 = a.T.reshape(12)
print(a.T.flags["C_CONTIGUOUS"]) # False 转置之后不连续了
print(np.shares_memory(a, r2)) # False ⚠️ 悄悄拷了一份
用同一张转置表试两种读取顺序。 默认 order="C" 让最后一轴先变。转置表开头取到 0, 4, 8, 1,在原缓冲区的字节偏移是 0, 32, 64, 8,相邻偏移差依次是 32, 32, −56,无法用一个一维步长表示。改用 order="F" 让第一轴先变,开头取到 0, 1, 2, 3,整张表按原缓冲区顺序每次走 8 字节,能返回一维视图。两次都得到 (12,),数值顺序不同。
以下用 NumPy 2.5 的 copy=False 明确要求不搬数据。若指定的顺序必须复制,reshape 会抛出 ValueError。NumPy 的 reshape 参数说明
import numpy as np
a = np.arange(12, dtype=np.int64).reshape(3, 4)
t = a.T # (4, 3)
flat_c = np.reshape(t, 12, order="C")
flat_f = np.reshape(t, 12, order="F", copy=False)
print(flat_c[:4].tolist(), np.shares_memory(t, flat_c)) # [0, 4, 8, 1] False
print(flat_f[:4].tolist(), np.shares_memory(t, flat_f)) # [0, 1, 2, 3] True
try:
np.reshape(t, 12, order="C", copy=False)
except ValueError:
print("C 序需要复制")
下面保留旧写法以便识别已有代码。给 .shape 赋值会改变对象本身的形状,NumPy 已弃用这种赋值方式。NumPy 的 shape 属性说明
import numpy as np
a = np.arange(12).reshape(3, 4)
a.shape = (4, 3) # ✅ 直接赋值 shape:不能零拷贝就抛 AttributeError
print(a.shape) # (4, 3)
🧩 六、.contiguous() 到底在修什么
有些操作要求输入满足特定的内存布局。NumPy 的 np.ascontiguousarray 返回按 C 序连续的数组,适合接口明确要求这种布局时使用。PyTorch 的 .contiguous() 也用于请求连续布局,本节用 NumPy 演示。
import numpy as np
a = np.arange(12).reshape(3, 4)
try:
a.T.view(np.int8)
except ValueError as e:
print("ValueError:", e)
# To change to a dtype of a different size, the last axis must be contiguous
b = np.ascontiguousarray(a.T) # ⭐ 拷一份连续的
print(b.view(np.int8).shape) # (4, 24) ✅ 通了
这里把元素从 8 字节重新解释成 1 字节,需要最后一轴的元素紧邻排列。在这张转置表里最后一轴步长是 32 字节,条件不满足。a.view() 不传参数时会保持原 dtype 并返回视图。a.view(新 dtype) 则用新的类型解释原字节,元素字节数改变时才有这里的最后一轴要求。NumPy 的 view 说明
连续性、共享和复制怎样分别判断?
flags.c_contiguous 检查一个数组能否按 C 序连续读。np.shares_memory(a, x) 比较两份数组是否有字节重叠。是否复制还要问是哪一步操作,例如同一个 ascontiguousarray 调用在不同输入上就会走不同的路径。
| 操作 | C 连续 | 与原表重叠 | 这一步复制数据 |
|---|---|---|---|
| 对原表倒序切片 | 否 | 是 | 否 |
| 把倒序视图转成 C 连续 | 是 | 否 | 是 |
| 要求原表 C 连续 | 是 | 是 | 否 |
先预测 packed 的第一行。连续化会把倒序视图的第一行 [3, 2, 1, 0] 依次放入新缓冲区,取值和视图相同,字节落点已经改变。直接把原表交给 ascontiguousarray,无需改布局或类型,本例会返回原对象。
import numpy as np
a = np.arange(12, dtype=np.int64).reshape(3, 4)
v = a[:, ::-1]
packed = np.ascontiguousarray(v)
same = np.ascontiguousarray(a)
for x in (v, packed, same):
print(x.flags.c_contiguous, np.shares_memory(a, x))
# False True
# True False
# True True
print(np.array_equal(v, packed), same is a) # True True
循环每次输出一对检查结果,顺序和上表一致。最后的 array_equal 比较取值,same is a 检查返回的是否为同一个对象。若需要独立数据,即使输入已经 C 连续,也应显式调用 .copy()。NumPy 的 ascontiguousarray 示例
📗 PyTorch 里 .contiguous() 的急救写法(什么时候要在 .transpose() 后面补一个)
在 ML 基础 · 附录C 手撕代码速查 里已经给了,
这一章只解释它为什么必须存在。
03 / 完整解释
把布局优势与安全边界分开。
🧩 七、连续性对速度的影响有多大
⚠️ 先说一个我自己踩的坑,因为它太容易得出错误结论:
❌ 这个对比是【无效】的:big.sum(axis=1) 对 big.T.sum(axis=0)。
这两句是同一次内存遍历 —— big.T 只换了说明书,axis 也跟着换了,走的字节顺序一模一样。
我第一版就是这么测的,结果「不连续」反而更快,因为测的根本不是连续性。
⭐ 公平的对比要拿同样的数据、同样的元素个数,只让内存布局不同:
import numpy as np, timeit
n = 4000
full = np.ones((n, n))
strided = full[:, ::2] # 隔列取,真正不连续
packed = np.ascontiguousarray(strided) # 同样的数据,连续存一份
print(strided.shape, strided.flags["C_CONTIGUOUS"]) # (4000, 2000) False
print(packed.shape, packed.flags["C_CONTIGUOUS"]) # (4000, 2000) True
t_s = min(timeit.repeat(lambda: strided.sum(), number=3, repeat=5)) / 3
t_p = min(timeit.repeat(lambda: packed.sum(), number=3, repeat=5)) / 3
print(f"不连续 {t_s*1000:.2f} ms 连续 {t_p*1000:.2f} ms 快 {t_s/t_p:.2f}x")
本机(numpy 2.4.6)实测:不连续 10.46 ms,连续 5.98 ms —— 快 1.75 倍,元素个数完全一样。
⚠️ 你的绝对数值会不同(取决于 CPU 缓存大小),但量级差异是结构性的: CPU 一次从内存搬的是一整条 cache line(通常 64 字节), 隔列取意味着搬进来的一半直接扔掉。
⭐ 什么时候值得先
ascontiguousarray一下: 一个不连续的数组要被反复扫描很多次时,先花一次拷贝的钱把它压实,通常划算。 只用一次就不必了 —— 拷贝本身也要遍历一遍。
🧩 八、as_strided:直接手写说明书
既然形状只是说明书,那能不能自己编一份?能,而且这是滑动窗口的经典实现:
import numpy as np
from numpy.lib.stride_tricks import as_strided
v = np.arange(8)
w = as_strided(v, shape=(6, 3), strides=(v.strides[0], v.strides[0]))
print(v)
# [0 1 2 3 4 5 6 7]
print(w)
# [[0 1 2]
# [1 2 3]
# [2 3 4]
# [3 4 5]
# [4 5 6]
# [5 6 7]]
print(np.shares_memory(v, w)) # True ⭐ 零拷贝
6×3 = 18 个数字,背后只有 8 个元素。两个 strides 都等于 8 字节,意思是「行号 +1 和列号 +1 都只挪一格」—— 于是每行自然比上一行错开一位。
💀 但这是本章最危险的一个 API:as_strided 不做任何边界检查。
shape 写大一格,它就去读数组后面那块不属于你的内存 —— 不报错,读出垃圾数,
运气不好直接段错误。
⭐ 实际工作中请用 np.lib.stride_tricks.sliding_window_view,它做同样的事但有边界检查:
import numpy as np
v = np.arange(8)
w = np.lib.stride_tricks.sliding_window_view(v, 3)
print(w.shape) # (6, 3)
print(np.shares_memory(v, w)) # True
as_strided 值得知道,是因为它把「形状只是说明书」这件事演示到了极致 —— 但别在生产代码里用它。
04 / 完整解释
从内存布局回到函数边界。
🔗 这一章连到哪里
| 相关的地方 | 为什么 |
|---|---|
| 04 · 视图还是拷贝 | 那一章区分共享与独立数据,本章解释起点和步长怎样让两种读法重叠。 |
| 06 · 索引的四种形态 | 基础切片用步长读取原数据。整数数组与布尔高级索引的读取按索引规则返回副本,即使所选元素碰巧等距。 |
| 11 · 从 NumPy 到 PyTorch | PyTorch 的张量是同一套说明书(storage + shape + stride + offset),.contiguous() 是同一件事 |
| ML 基础 · 附录C 手撕代码速查 | .contiguous() 的急救写法在那里:什么时候要在 .transpose() 后面补一个 |
| 框架底下是 C++ · 03 · cache 与数据布局 | 本章第七节那个 1.75 倍差在硬件上是怎么来的:cache line、预取、AoS/SoA |
✅ 检查点
a = np.arange(12).reshape(3, 4)的strides是多少?单位是什么?- 为什么
a.T对一个巨大的矩阵也是瞬间返回? a[2, 1]的字节偏移怎么算出来?算给我看。- 对上面的
v = a[:, ::-1],v[0, 3]相对视图起点和原表起点各偏移多少字节?值是多少? a.T.base is a是True还是False?为什么?那该用什么判断共享内存?- C 序和 F 序存
[[1,2,3],[4,5,6]],内存里的字节顺序分别是什么? a.T.reshape(12)会不会拷贝?怎么让「要拷贝就报错」而不是偷偷拷?a.T.view(np.int8)报的错原文是什么?它抱怨的到底是哪件事?- 拿
big.sum(axis=1)和big.T.sum(axis=0)比较连续性的影响,错在哪? as_strided为什么危险?该用什么替代?
👀 答案
(32, 8),单位是字节。行 +1 挪 32 字节(4 个 int64 = 一整行),列 +1 挪 8 字节(1 个 int64)。- 因为它一个字节都没搬,只是把 shape 和 strides 同时倒过来 ——
(3,4)/(32,8)变成(4,3)/(8,32)。干活的是后面真正读数据的那一步。 2 * 32 + 1 * 8 = 72字节,72 // 8 = 9,从 0 数的第 9 格,a.ravel()[9] == 9。- 相对视图起点是
0 × 32 + 3 × (−8) = −24字节。视图起点原本在原表起点之后 24 字节,所以相对原表偏移是24 − 24 = 0字节,值为a[0, 0] = 0。 False。.base不是「上一层」,在本例中跳过中间视图、指向原始数组 ——a.T.base is base才是True(base是原始的arange(12))。判断共享内存要用np.shares_memory(a, a.T),它不会被中间层骗到。- C 序
[1, 2, 3, 4, 5, 6](按行铺),F 序[1, 4, 2, 5, 3, 6](按列铺)。strides 分别是(3,1)和(1,2)。⚠️ 要用dtype=np.int8才看得出来,int64 前 7 个字节全是 0。 - 本例默认按 C 序读转置表,原数据的读取位置无法用单个步长表示,所以会复制。按 F 序读可以返回视图,但结果顺序不同。对需要复制的 C 序写法指定
copy=False,就会得到ValueError。 To change to a dtype of a different size, the last axis must be contiguous。改变每个元素的字节数时,view要求最后一轴的元素相邻,本例的转置表在这根轴上有间隔。- 错在那两句是同一次内存遍历:
big.T只换了说明书、axis也跟着换了,走过的字节顺序一模一样,测的根本不是连续性。公平做法是同样的数据、同样的元素个数,只让布局不同(full[:, ::2]vsnp.ascontiguousarray(...)),实测 10.46 ms vs 5.98 ms,快 1.75 倍。 - 因为它不做任何边界检查 —— shape 写大一格就会去读不属于你的内存,不报错、读出垃圾数,运气不好直接段错误。生产代码用
np.lib.stride_tricks.sliding_window_view,同样零拷贝但有边界检查。
本节回顾
⚡ 走神救援
⭐ 找格子时,先选对起点,再加上每个下标乘对应步长。 倒序切片会把逻辑起点换到原来的末端,相应步长变成负数。
np.arange(12).reshape(3, 4)的 strides 是(32, 8),单位是字节:行号 +1 挪 32 字节(一整行),列号 +1 挪 8 字节(一个元素)。任意下标一次乘加就出地址 ——a[2,1]=2*32 + 1*8 = 72字节 = 第 9 个元素。这就是索引 O(1) 的全部秘密。转置因此是免费的:a.T只把 shape 和 strides 同时倒过来,一个字节都没搬。⚠️ 判断共不共享内存永远用
np.shares_memory,别用.base—— 它两个方向都骗人:a.T.base is a是False(本例跳过了中间视图);而a.T.reshape(12)明明是拷贝,.base却不是None(挂在中间临时数组上)。二维表的 C 序先变列号,F 序先变行号。先确定读取顺序,再判断
reshape能否沿用原缓冲区。想让必须复制的重塑报错,可用np.reshape(..., copy=False)。连续性看flags,两份数组的字节重叠看np.shares_memory。连续性的真实代价实测 1.75 倍(4000×2000,不连续 10.46 ms vs 连续 5.98 ms)—— CPU 一次搬一整条 cache line,隔列取等于搬进来一半就扔。
as_strided能手写说明书做出零拷贝滑动窗口,但它不做边界检查,生产代码用sliding_window_view。
下一节 👉 06-索引的四种形态.md