DataLoader:训练循环到底在等哪里?
把 DataLoader 建模成生产者-消费者系统,分别测量批次等待与训练工作,用受控的 worker、预取、持久化与争用实验找到真正限制输入吞吐的资源。
这里有两条受控训练流水线。同样 batch,同样机器,同样合成的 batch 后工作负载。每个样本也带着同样名义两毫秒代价:在一条流水线里那是等待,在另一条里是固定 CPU 工作。
两边代价周围的张量构造相同。变的是这两毫秒消耗的资源。
两边给同样 treatment——num_workers 从 0 加到 8——同样方式测量。
=== producer=sleep 2.0 ms/sample batch=32 consumer=8 ms/batch ===
workers ex/s wait_mean wait_p50 wait_p95 wait_max work wait_frac
0 414 69.8 69.8 70.4 70.7 7.5 0.90
1 452 62.6 62.3 65.9 66.4 8.1 0.89
2 890 27.3 25.3 56.8 57.7 8.6 0.76
4 1769 8.4 2.1 30.3 30.5 9.7 0.46
8 3049 0.9 0.9 2.7 3.5 9.6 0.09
=== producer=spin 2.0 ms/sample batch=32 consumer=8 ms/batch ===
workers ex/s wait_mean wait_p50 wait_p95 wait_max work wait_frac
0 454 62.8 62.1 66.5 89.1 7.8 0.89
1 451 56.9 56.4 62.4 79.7 14.0 0.80
2 456 49.5 47.7 103.8 107.2 20.7 0.71
4 458 38.0 21.9 121.1 134.2 31.9 0.54
8 449 28.1 24.0 88.2 110.2 43.2 0.39
第一条快了 7.4 倍。第二条完全没快:0 worker 454 样本每秒,8 worker 449。
看大多数人会看的那列。第二张表 wait_mean——训练循环阻塞等下一 batch 多久——从 62.8ms 降到 28.1ms。r r每步等数据的比例从 0.89 降到 0.39。按这个测量输入流水线巨大改进。按付电费的测量,什么都没发生。
时间没消失,搬家了。work 列——batch 到达后训练步本身的时间——从 7.8ms 涨到 43.2ms。八个 worker 进程争同样核,训练步慢了五倍,步自己慢到不等人了。
本章讲不被这个骗,不被骗的办法是不把 DataLoader 当带调参的函数,当带可测量阶段的系统。
我们在哪
第 5 章把模型完整描述了。模块是已注册孩子、参数与缓冲的树,问框架它以为自己拥有什么而不是从源码推测。Python 可达、已注册 state、autograd 依赖、优化器成员——四套独立结构都能检查,每套都可检查。
但本书到此每个训练循环都从这样一行开始:
x, y = X_train, y_train
数据已在那。已解码,已 batch,已是正确 dtype,已驻内存,循环要的时刻正好有。这个假设在悄悄干巨量的活,真实训练免费拿不到。每个优化器步之前,得有东西产出下一 batch。
所以本章的问题:
下一 batch 到达训练步之前必须发生什么, arrival 太慢时系统到底在等哪里?
读完,你应该能拿慢或不稳的流水线,把训练步拆阶段,在每边界测可见等待,说出哪个阶段跟不上,改一个机制,用端到端证据证明瓶颈移动了还是只是搬家了。
这些数从什么环境来
本章每个测量产自一台机器,没有一个值该指望复现:
PyTorch 2.13.0
Python 3.12.3
OS Linux (container), fork start method
CPU 1 vCPU
CUDA not available
threads torch.get_num_threads() == 1
单核是故意苛刻的约束,本章顶部两张表分歧如此干净就靠它。单核上 CPU-bound 生产者不可能扩展,latency-bound 生产者扩展漂亮。你八核笔记本上两曲线都平缓些,交叉点在别处。
这正是要点而不是 caveat。有用的 artifact 是测量流程,不是它在别人硬件上产出的数。
你实际在训的系统
人人画的训练图是这样:
batch → model → loss → backward → optimizer
跑起来的系统更像这样,中间的箭头是要紧的那个:
PRODUCER
storage / source
↓
sample production
(__getitem__ or __iter__)
↓
read / decode / parse / transform
↓
collate / batch construction
↓
worker process
│
└──────── process boundary ────────→ main training process
↓
prepared batch
batch 跨进训练进程后,还要再走:
CPU batch → host-to-device transfer → forward → backward → optimizer step
两处产出 work,一处消费,中间有队列。人人当魔法调速旋钮的每个 DataLoader 参数都是图中某部分的性质:
| Argument | What it changes in the system |
|---|---|
num_workers |
多少进程并发产出样本 |
prefetch_factor |
消费者前面可排多少备好的 work |
persistent_workers |
生产者进程在迭代器之间活不活 |
collate_fn |
生产路径的一部分,不是之后的东西 |
batch_size |
每步取数、整理事件与消费者 workload |
pin_memory |
成品 batch 住什么样的主机内存 |
没有一个能让永久更慢的生产者跑赢消费者。它们改并发、队列深、进程生命与内存位置。握住这个区分就是本章大半诊断价值。
四个不是一回事的量
测任何东西前,先分开日常对话塌成“速度”的四个意思:
PRODUCER THROUGHPUT how fast batches can be prepared
CONSUMER THROUGHPUT how fast training can use them
BUFFERING how much temporary mismatch can be hidden
END-TO-END THROUGHPUT how many examples actually complete per second
生产者慢于消费者,消费者终究等,队列再深也防不住:缓冲按两速率之差排空。生产者快于消费者,加生产并发除了耗资源什么都不买——正是本章顶部第二张表,多花的资源出自消费者自己的预算。
预取藏暂时 mismatch。藏不住永久的。
加速器利用率低是有很多病因的症状。它不是诊断,也不是输入流水线慢的证据。
训练循环 idle 可能是 batch 到晚了,传输贵了,模型核太小填不满设备,核之间 CPU 侧 Python 慢了,或 workload 本来就小。修法各不同。所以别从“利用率低,所以加 num_workers”开始。从步的时间到底去哪的测量开始。
拆开这一步
最小有用的仪器把等下一 batch 的可见等待与之后的一切分开。
from time import perf_counter
t0 = perf_counter()
batch = next(iterator) # how long the consumer was blocked
t1 = perf_counter()
train_step(batch) # what it did once it had work
t2 = perf_counter()
思想就这些。其余是周围 bookkeeping,bookkeeping 重要因为三细节否则毁掉测量:启动不是稳态,平均藏 stall,两数之比不是 verdict。
这里是本章每张计时表用的 harness。
import time
import statistics
from time import perf_counter
import torch
from torch.utils.data import Dataset, DataLoader
# ~24,500 iterations of this loop cost about 1 ms of CPU on the reference
# machine. Calibrate it on yours before comparing any absolute numbers.
ITERS_PER_MS = 24_500
def spin(milliseconds):
"""Consume a fixed amount of CPU work. Needs a core; sleeping does not."""
total = 0.0
for i in range(int(milliseconds * ITERS_PER_MS)):
total += i * 0.5
return total
class Producer(Dataset):
"""A sample source whose cost is controllable and deliberately visible."""
def __init__(self, size=8192, dim=128, cost_ms=2.0, mode="sleep"):
self.size, self.dim = size, dim
self.cost_ms, self.mode = cost_ms, mode
def __len__(self):
return self.size
def __getitem__(self, index):
if self.mode == "sleep":
time.sleep(self.cost_ms / 1000) # waiting on something external
else:
spin(self.cost_ms) # work that needs a CPU
x = torch.randn(self.dim)
y = torch.randint(0, 10, ()).long()
return x, y
def measure(loader, batches=30, warmup=8, consume=lambda b: None):
"""Split each step into the visible wait for the batch and the work after it."""
it = iter(loader)
waits, works = [], []
for i in range(batches + warmup):
t0 = perf_counter()
try:
batch = next(it)
except StopIteration:
break
t1 = perf_counter()
consume(batch)
t2 = perf_counter()
if i >= warmup:
waits.append(t1 - t0)
works.append(t2 - t1)
n = len(waits)
total = sum(waits) + sum(works)
ordered = sorted(waits)
return {
"batches": n,
"wait_mean_ms": 1000 * statistics.fmean(waits),
"wait_p50_ms": 1000 * statistics.median(waits),
"wait_p95_ms": 1000 * ordered[min(n - 1, int(0.95 * n))],
"wait_max_ms": 1000 * max(waits),
"work_mean_ms": 1000 * statistics.fmean(works),
"wait_fraction": sum(waits) / total,
# Correct for the controlled benchmark below because every measured
# batch is full. General-purpose loader benchmarks should count the
# actual number of examples returned.
"examples_per_s": n * loader.batch_size / total,
}
里面两设计决定值得辩护。
spin 消耗固定 work,不是固定 wall-clock。 这个 harness 早版 busy-wait 到 perf_counter() 截止。那对我们要研究的情形错了:八进程争单核时,两毫秒截止在消耗远不足两毫秒 CPU 的情况下满足,“CPU-bound”生产者悄悄退化成 sleeping,要测的争用从结果消失。固定迭代数没这个问题。机器 oversubscribed 时同样 work 就是更久,这正是要看的。
sleep 与 spin 是真实谱的两端。 实践里样本生产是等存储/网络与烧 CPU 做 decode、解析、变换的混合。两成分对 worker 并发的反应相反,分开是最快建对直觉的办法。JPEG decode 大多 spin。对象存储读大多 sleep。冷网络文件系统的小文件大多 sleep 带 spin 尾。
等待比是问题,不是答案
很想把测量缩成一个数:
wait_fraction = data_seconds / (data_seconds + work_seconds)
再贴阈值:0.1 下健康,0.5 上坏了。忍住。回本章顶部 spin 表,把最后两列合读:
workers ex/s work wait_frac
0 454 7.8 0.89
8 449 43.2 0.39
等待比减半还多。端到端吞吐没动。系统毫无变化、指标好 56% 的指标不是健康指标;它是比值,比值两边动它都动。
比值仍值得算,因为它告诉你先查边界哪边。只是它不是 verdict,不连吞吐一起比就不能跨配置比。
单阈值不可信还有第二个原因:同样数在不同规模意思不同。等数据的 10% run 一周值得干几天。等 30% 实验四分钟跑完无关紧要。数的含义来自 job,不来自书里的表。
拿可见等待与这个 workload 的有用功比,再测减小大头是否提高端到端样本每秒。吞吐是 verdict;比值只决定看哪。
num_workers 改并发,不改速度
num_workers=0 时 DataLoader 在主进程、next() 调用里做样本取与整理。主线程忙时没有 DataLoader worker 进程准备未来 batch。
这个模式好推理:同步产出下一 batch 的时间直接 delay 主机推进训练循环。别处已发出的异步工作——比如 CUDA work——是另一个问题,别和 DataLoader 预取搞混。
num_workers 大于零,DataLoader 起 worker 进程,把数据生产搬过进程边界。
map 式数据集,主进程 sampler 产出下标派发给 worker。IterableDataset 每个 worker 前进自己的数据集迭代器 replica。
两种情形 worker 都能在主训练进程消费 earlier batch 时准备数据,消费者就能训 batch N 时 worker 准备 N+1、N+2 等等。
机制就这些,两张表都解释了。
worker 何时帮忙
=== producer=sleep 2.0 ms/sample batch=32 consumer=8 ms/batch ===
workers ex/s wait_mean wait_p50 wait_p95 wait_max work wait_frac
0 414 69.8 69.8 70.4 70.7 7.5 0.90
1 452 62.6 62.3 65.9 66.4 8.1 0.89
2 890 27.3 25.3 56.8 57.7 8.6 0.76
4 1769 8.4 2.1 30.3 30.5 9.7 0.46
8 3049 0.9 0.9 2.7 3.5 9.6 0.09
16 3106 1.1 0.3 4.2 11.3 9.2 0.11
单核机器上 7.5 倍吞吐。这个数值得坐一会儿,因为它直接违反这个领域最常见的 rule of thumb。生产者在等而不是在算时 worker 数不受核数 bound——sleeping 进程不要 CPU,三十二个两毫秒 sleep 几乎完美重叠。
也注意扩展停在哪。8 到 16 worker,吞吐 3049 到 3106,没动。原因在同行可见:wait_mean 已 0.9ms 而 work 9.6ms。生产者已快于消费者。训练循环要 batch 时队列里总有,循环速率完全由自己的 work 定:
32 examples / 10.5 ms per step ≈ 3050 examples/s
正是测量值。到边界这头,生产者并发再加什么都不买,只花内存与进程。认出这个 state——等待近零、吞吐对上消费者 work——就知道停调 loader 去看模型。
worker 何时不帮忙
=== producer=spin 2.0 ms/sample batch=32 consumer=8 ms/batch ===
workers ex/s wait_mean wait_p50 wait_p95 wait_max work wait_frac
0 454 62.8 62.1 66.5 89.1 7.8 0.89
1 451 56.9 56.4 62.4 79.7 14.0 0.80
2 456 49.5 47.7 103.8 107.2 20.7 0.71
4 458 38.0 21.9 121.1 134.2 31.9 0.54
8 449 28.1 24.0 88.2 110.2 43.2 0.39
16 441 19.5 16.4 52.6 52.8 53.1 0.27
完全平。这个跑之前能从第一性原理预测,值得做,因为它把神秘结果变成算术。
产出一 batch 要 32 样本 × 2ms = 64ms CPU。训练步另 8ms。每 batch 72ms CPU work,机器单核,所以:
32 examples / 72 ms ≈ 444 examples/s
表里每行 441 到 458 之间。并发变不出第二核。它重排单核何时干活,排法在两具体处更糟。
work 列是第一处。生产者多了,从训练步抢核,步本身从 7.8ms 慢到 53.1ms。消费者没变,环境变了。
尾是第二处,更丑。0 worker 最大观测等待 89ms、中位 62ms——慢,但完全规律。4 worker 中位降到 22ms 而 p95 升到 121ms、最大 135ms。流水线变 bursty:有时 batch 瞬时有,有时调度器没给相关 worker 时间,循环 stall 六倍中位。平均降了,可预测塌了。
平均藏 starvation。mean 旁边记 median、p95 与最大等待,因为 mean 3ms、尾 200ms 的流水线饿加速器的方式 mean 表达不了。
解释与怎么办
名义代价相同的两生产者,同样机器,同样旋钮,相反结局。分开它们的推理与 DataLoader 无关:
并发把 idle 等待变成吞吐。它变不出已饱和的资源。
生产者在等进程外的东西,更多 worker 重叠更多等待,扩展能远超核数。生产者在算,更多 worker 争固定资源,扩展止于该资源——再往下,尾里往下。
所以 worker sweep 的有用结论从来不是“四是对的数”。它是刻画:
OBSERVATION the training loop blocks 62 ms per step waiting for batches
HYPOTHESIS sample production cannot keep up
EXPERIMENT sweep num_workers 0 → 1 → 2 → 4 → 8, recording
examples/s, wait mean/p95, and post-batch work time
RESULT wait falls, work rises, examples/s is unchanged
INTERPRETATION production is CPU-limited on this machine; the workers and
the training step are competing for the same cores
NEXT decompose sample production into read/decode/transform/collate
and move deterministic work out of the hot path
最后一步真修复通常住那,部分是另一章的 territory:第 7 章拥有变换含义,跑它们的代价这里可测。
线程 oversubscription 是同样事的特例
spin 生产者争核的方式 obvious。真实 worker 常 invisible 地争,因为它们调的库自带线程池。调线程化线性代数后端、图像 codec、数值库的 worker,每个 worker 进程 spawn 与机器核数一样多的线程——八 worker 进程里各八个。
8 worker processes × 8 library threads = 64 runnable threads on 8 cores
症状就是 spin 表:worker 越多,吞吐平或降,步时间膨胀,尾丑,机器看起来占满而没干多少。
PyTorch 自带 worker 实现已处理一种常见 oversubscription:PyTorch 2.13 里每个 DataLoader worker 调:
启动不是稳态
上面每个测量都丢了前八 batch。原因如下。
=== time to first batch vs steady-state batch ===
workers first_batch_ms steady_mean_ms
0 71.6 69.9
2 128.9 35.6
8 279.7 6.6
8 worker 首 batch 280ms,稳态典型 batch 6.6ms——42 倍。只计时前几 batch 的 benchmark 会报告 8 worker 比 0 差四倍,与真相正好相反。
代价是真的。起八进程、每进程 import 模块、建八数据集 replica、填预取队列都要时间,transient 不等于免费。重要否取决于 job 的形状:
startup latency pay it once per iterator; dominates short jobs and
frequently re-created loaders
steady-state throughput what a long training run is actually limited by
tail / stall behavior what starves an accelerator even at good averages
三不同量,改动能好一个坏另一个。加 worker 这里稳态好 10×、启动坏 4×。跑一周的 run obviously 对。每 epoch 跑十二 batch 的验证循环未必。
所以:测稳态前 warm up,job 常付启动就单独测启动。
persistent_workers 管生命
默认 worker 进程迭代器建时生、耗尽时死。for batch in loader: 每 epoch 一次的训练循环每 epoch 付一次上面启动代价。
persistent_workers=True 让它们在迭代器之间活着。
=== 5 short epochs, wall-clock seconds ===
persistent_workers=False 1.17 s
persistent_workers=True 0.73 s
短 epoch,四 worker,计时前已付启动。38%,来自改了零计算的设置。省的 scale 按建迭代器多频与 worker 启动多贵,benchmark 得跨多 epoch——测单迭代器什么都看不出。
但这不是免费性能开关,因为进程活着 state 就活着。
import os
class Counting(Dataset):
def __init__(self):
self.calls = 0
def __len__(self):
return 4
def __getitem__(self, i):
self.calls += 1
return torch.tensor([os.getpid() % 10000, self.calls])
persistent_workers=False
epoch 0 (pid, calls) = [[766, 1], [766, 2], [766, 3], [766, 4]]
epoch 1 (pid, calls) = [[770, 1], [770, 2], [770, 3], [770, 4]]
epoch 2 (pid, calls) = [[774, 1], [774, 2], [774, 3], [774, 4]]
parent dataset .calls = 0
persistent_workers=True
epoch 0 (pid, calls) = [[778, 1], [778, 2], [778, 3], [778, 4]]
epoch 1 (pid, calls) = [[778, 5], [778, 6], [778, 7], [778, 8]]
epoch 2 (pid, calls) = [[778, 9], [778, 10], [778, 11], [778, 12]]
parent dataset .calls = 0
输出三处值得注意。
第一块进程号变,第二块不变。这就是生命,直接观测。
第一块计数器重置,第二块累积。数据集缓存、计数、前进 cursor、握 open handle、按产出量改变行为,persistent_workers=True 改它 epoch 2 干什么。这是性能设置送的语义变化。
两情形 parent dataset .calls 都是零。训练脚本里数据集对象从不是干活的对象。worker 在自己的 replica 上干,改动传不回。这是多进程下数据集最常见的困惑:self 上累积的 instrumentation 在 num_workers=0 完美 work,在 num_workers=4 悄悄报零。
所以要问的是两个问题:
重复 worker 启动对这个 job 是可测代价吗,这个数据集的 worker-local state 跨 epoch 带安全吗?
prefetch_factor 是队列深
prefetch_factor 控每 worker 在消费者前面备好多少 batch。真语义值得确认而不是 assumed:
{'num_workers': 0} -> loader.prefetch_factor = None
{'num_workers': 2} -> loader.prefetch_factor = 2
num_workers=0 + prefetch_factor=2 -> ValueError prefetch_factor option could
only be specified in multiprocessing.let num_workers > 0 to enable
multiprocessing, otherwise set prefetch_factor to None.
num_workers=0 + persistent_workers=True -> ValueError persistent_workers
option needs num_workers > 0
所以默认 None,有 worker 时每 worker 解析成 2,没 worker 时传参直接拒绝。prefetch_factor 与 persistent_workers 没 worker 进程就没意义,PyTorch 说出来而不是无视你。
现在是要紧的部分。深队列被广泛相信更快:
=== prefetch_factor (sleep producer, 2 workers) ===
prefetch ex/s wait_mean wait_p95 wait_max
1 894 27.8 47.3 49.8
2 903 26.1 53.2 54.2
4 912 27.0 54.8 55.4
8 906 27.3 56.1 57.2
队列深八倍,噪声内平,顶端尾略差。
这正是机制预测的。预取藏生产 latency 的方差:让跑前的 worker 盖住掉队的 worker。这个生产者每次精确睡两毫秒,无方差可藏,深队列白在内存里多握 batch。固定速率低于消费者需求的两 worker,队列能装两 batch 还是十六 batch,饿消费者一模一样。
队列深买的是对不规则生产的容忍。它提不高永久太慢的生产者的平均速率。
等尾坏、mean 好的时候加深——那是方差问题,正是预取解的问题。盲目加深买的是内存压力。
folk 公式
in-flight batch memory ≈ num_workers × prefetch_factor × batch bytes
对同时活着多少 batch payload 是 reasonable 量级直觉,不是 RAM 公式。它漏了 worker 进程开销、每 worker Python 解释器、每 replica 数据集 state、__getitem__ 与 collate_fn 里中间对象、进程间搬数据的拷贝。拿它理解为什么三设置都往内存同方向推,别拿它预测数。
payload 部分要测而不是估:
def tensor_payload_bytes(obj):
if torch.is_tensor(obj):
return obj.numel() * obj.element_size()
if isinstance(obj, dict):
return sum(tensor_payload_bytes(v) for v in obj.values())
if isinstance(obj, (tuple, list)):
return sum(tensor_payload_bytes(v) for v in obj)
return 0
这测从一个 batch 对象到得了的张量 payload。不是进程内存,直说这区别就是有用估计与误导估计的区别。
流水线爆共享内存或 RAM,推在途数据的三设置是 num_workers、prefetch_factor、batch_size。逐个降。降某个故障消失,你拿到的是证据不是猜。容器多一处查,因为共享内存段住 /dev/shm,容器默认值常比主机小得多。
生产者包括 collate_fn
常见而贵的错是 profile Dataset.__getitem__ 就说 profile 了数据加载。batch 构造还有堆叠、padding、排序、打包、类型转换与你写的 Python。
=== a cheap sample source with an expensive collate_fn ===
workers collate ex/s wait_mean
0 default 3389 1.9
0 slow 857 29.8
2 default 3080 2.7
2 slow 831 18.7
样本源每样本 0.05ms——32 的 batch 1.6ms。collate_fn 30ms。__getitem__ 的 profile 报告快速健康的数据集,吞吐掉四倍。
注意两 worker 也没救回来,前面确立的原因:这个 collate 是单核机器上的 CPU work,搬进 worker 进程是搬家,不是并行。
测阶段,不测你怀疑的 API 名。
生产者确认为瓶颈后的一般形式是把样本生产拆零件分别计时:
read → decode / parse → transform → collate
图像、文本、音频、表格、远端对象存储都适用,通常找到两样之一:比预期贵得多的阶段,或每 epoch 无故重算的确定性阶段。后者尤其值钱,因为确定性 work 可能是预计算或缓存的候选,而不是每 epoch 重算。
搬出 hot path 值不值取决于缓存大小、存储带宽、失效要求、变换是否真与训练时上下文独立。
worker 里计时要小心,持久化实验说明了原因:self 上累积传不回主进程。把计时随样本返回。
class ProfiledDataset(Dataset):
def __getitem__(self, index):
t0 = perf_counter()
raw = self.read(index)
t1 = perf_counter()
item = self.transform(raw)
t2 = perf_counter()
return {"x": item, "read_s": t1 - t0, "transform_s": t2 - t1}
默认整理把那些浮点堆成张量,主进程聚合。
进程边界
第 5 章讲单进程里结构间分歧。worker 引入进程间边界,改几件容易 assumed 掉的东西:异常、数据集 state、随机数发生器、文件句柄、数据库连接、缓存、多少共享。
从响亮失败开始,因为它有干净流程。
worker 崩溃与诊断它的仪器
这里有个一坏样本的数据集——下标 37 解码成 None, corrupt 文件或缺记录到你代码时就是这样。
def decode(i):
if i == 37:
return None
return torch.randn(4)
class D(Dataset):
def __len__(self):
return 64
def __getitem__(self, i):
return decode(i) * 2.0
有 worker 时失败包着到:
File ".../torch/utils/data/dataloader.py", line 1567, in _process_data
data.reraise()
File ".../torch/_utils.py", line 794, in reraise
raise exception
TypeError: Caught TypeError in DataLoader worker process 0.
Original Traceback (most recent call last):
File ".../torch/utils/data/_utils/worker.py", line 374, in _worker_loop
data = fetcher.fetch(index)
File ".../torch/utils/data/_utils/fetch.py", line 54, in fetch
data = [self.dataset[idx] for idx in possibly_batched_index]
File "probe9.py", line 13, in __getitem__
return decode(i) * 2.0
TypeError: unsupported operand type(s) for *: 'NoneType' and 'float'
这是好情形。PyTorch 在 worker 抓住异常,序列化,主进程重抛并附原 traceback。拿到失败行。
坏情形长这样,每个 PyTorch 用户都见过:
File ".../torch/utils/data/dataloader.py", line 1304, in _try_get_data
raise RuntimeError(
RuntimeError: DataLoader worker (pid(s) 803) exited unexpectedly
进程死了而不是抛了才有这个信息——OOM killer 杀的、信号终止的、C 扩展里 segfault 的。没有 Python 异常可转,没东西告诉你。
两情形流程一样,本书反复回来的诊断动作:去掉边界看失败活不活。
reproduce with num_workers=0
↓
does the underlying dataset operation itself fail?
↓
yes → the bug is in sample production. You now have a direct traceback
pointing at the failing line, and you can find the failing index.
no → the bug is in something the multiprocessing boundary introduced.
Try num_workers=1 next: the smallest failing worker count is
informative, and one worker eliminates worker-to-worker contention.
上面 None 样本,num_workers=0 给出同样 TypeError,四帧 traceback 无包装。失败在去掉边界后活着,多进程从没参与——只 obscured 报告。
失败不活着,嫌疑具体:跨 fork 不安全的库、父建子用的资源句柄、共享而不是每 worker 打开的数据库/网络客户端、继承时锁住的锁、worker 数乘 state 后才出现的内存压力,或 spawn 平台子 import 时重跑的模块层代码。
最后一条值得具体说,因为 spawn 启动法下尤其可见。
Windows 与 macOS 默认 spawn。Unix 默认依 Python 版本,也可显式配置:当前 PyTorch 文档说 Python 3.14 前 fork、3.14 起 forkserver。spawn 下子进程 import 你的主模块。建 loader 与开始迭代放模块层,子也做,递归。
def main():
loader = DataLoader(MyDataset(), batch_size=64, num_workers=4)
for batch in loader:
train(batch)
if __name__ == "__main__":
main()
guard 不是装饰。它是拦住子重跑程序的东西。
worker 拥有的资源同样逻辑:lazy 建,在 worker 里,第一次用时。
class RemoteDataset(Dataset):
def __init__(self, keys):
self.keys = keys
self.client = None # created per worker, on demand
def _get_client(self):
if self.client is None:
self.client = open_client()
return self.client
def __getitem__(self, index):
return self._get_client().fetch(self.keys[index])
每 worker 有自己的数据集 replica,这个模式让每 worker 第一次要时 lazy 建自己的 client。父里没建活 client 对象再继承或序列化进 worker。
够不够还取决于 client 库自己的多进程保证,得查不能 assumed。
还有条看起来 arbitrary 的规则值得留着:别从 worker 返回 CUDA 张量。原因不是 CUDA 张量在多进程里 categorically 禁止。问题是跨进程边界共享 CUDA 张量与 CUDA state 带来额外的生命、同步与多进程约束,普通输入加载不该管这些。
PyTorch 因此推荐更简单的多进程加载结构:
workers produce CPU batches → main process moves them to the device → model
fork 下的数据集 state
会看到“每 worker 一份完整数据集拷贝在 RAM”的说法。太强到无用,且平台相关。
fork 系统子初始 copy-on-write 共享父内存页,大只读结构不立刻复制。但 CPython 引用计数住对象头,碰 Python 对象就写页触发拷贝。百万路径字符串的大 Python 列表,worker 走一遍就逐渐复制,看起来像随 worker 数 scale 的慢内存泄漏。spawn 系统数据集序列化到每个子,代价 upfront 付。
两平台都成立的说法更窄但仍 actionable:
数据集上附的大 Python 对象图跨 worker 进程乘开后变贵,贵法依启动法而定。在目标平台测 scale 而不是推理。
真要修,state 做紧凑而不是放弃 worker:数组代替 boxed 对象列表、内存映射文件、列式格式、每 worker 加载的索引而不是继承的。
并发能改变正确性
前面都讲速度。这里有个开 worker 改变程序算什么的失败,无异常无警告。
map 式数据集暴露 keyed 或 indexed 样本访问。多进程加载下主进程 sampler 产出下标派发给 worker。
意味着 worker 不独立遍历全数据集,num_workers 加大不像我们天真的 IterableDataset 那样乘数据集。
sampler 仍可能故意产出同一 index 多次——比如有放回采样或自定义采样策略。那重复来自 sampler,不是每 worker 独立重放数据集。
IterableDataset 是流。它实现 __iter__ 按喜欢的顺序产出样本,要的就是装不进内存、从网络来、无有意义长度的数据。每 worker 拿到自己的数据集 replica——并调它的 __iter__。
from torch.utils.data import IterableDataset
class Naive(IterableDataset):
def __init__(self, n):
self.n = n
def __iter__(self):
yield from range(self.n)
十二个条目。数出来什么。
num_workers=0: emitted=12 unique=12 max_copies=1
order: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
num_workers=1: emitted=12 unique=12 max_copies=1
order: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
num_workers=2: emitted=24 unique=12 max_copies=2
order: [0, 1, 2, 3, 0, 1, 2, 3, 4, 5, 6, 7, 4, 5, 6, 7, 8, 9, 10, 11, 8, 9, 10, 11]
num_workers=3: emitted=36 unique=12 max_copies=3
order: [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, ...]
两 worker,“epoch”里每样本两次。三 worker 三次。数据集被要求每 worker 产流一次,它照做了,因为 __iter__ 里不知道自己是几个 replica 之一。
什么都不抛。损失下降。epoch 花的时间符合预期——甚至样本每秒看起来更快,因为处理了更多样本。dashboard 每个数 plausible。模型在悄悄 k 倍尺寸、每样本每 epoch 重复 k 次的数据集上训练,改有效采样分布、“epoch”含义、每次运行互相可比性,划分在下游做时还改训练验证集关系。
这是第 5 章的课换个系统。那里四套结构对属于模型什么不一致。这里 worker 数改变过一遍数据的含义,只有一个含义是你写下的那个。
给生产者加并发时,验证并行生产者划分 work 而不是复制 work。证据是每 epoch 唯一样本数,不是损失曲线。
注意 num_workers=1 干净,这让它当测试很差。bug 要两生产者才可见,1 worker 验证、8 worker 部署的流水线会错。
修复
get_worker_info() 主进程返回 None,worker 里返回描述当前 worker 的记录。
from torch.utils.data import get_worker_info
class Sharded(IterableDataset):
def __init__(self, n):
self.n = n
def __iter__(self):
info = get_worker_info()
if info is None:
yield from range(self.n)
else:
yield from range(info.id, self.n, info.num_workers)
每 worker 取流的 strided 切片。worker 0 取 0、3、6、9;worker 1 取 1、4、7、10;等等。切片 disjoint 并覆盖一切。
workers=0: emitted=12 unique=12 max_copies=1
order: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
workers=2: emitted=12 unique=12 max_copies=1
order: [0, 2, 4, 6, 1, 3, 5, 7, 8, 10, 9, 11]
workers=3: emitted=12 unique=12 max_copies=1
order: [0, 3, 6, 9, 1, 4, 7, 10, 2, 5, 8, 11]
workers=5: emitted=12 unique=12 max_copies=1
order: [0, 5, 10, 1, 6, 11, 2, 7, 3, 8, 4, 9]
十二样本,十二唯一,worker 数任意包括整除不了的。range(start, stop, step) 形式不用手算连续块边界处理不齐,值得用手算。
交错输出顺序值得注意而不是修。这次跑产出 worker 切片的交错而不是原流顺序。
别让正确性依赖 assumed 的 round-robin worker 调度。当前 DataLoader 多进程加载默认 in_order=True,强制它期待的先进先出 batch 顺序。显式置 in_order=False 允许 batch 乱序返回,影响可复现性与观测数据分布。数据有有意义顺序,跨 worker striding 毁了它,要连续切片——那是关于数据的决定,故意做,而不是稍后发现。
还有个容易漏的后果。batch 在 worker 内形成,用该 worker 的切片:
loader = DataLoader(Report(12), batch_size=6, num_workers=3)
[[0, 0], [0, 3], [0, 6], [0, 9]]
[[1, 1], [1, 4], [1, 7], [1, 10]]
[[2, 2], [2, 5], [2, 8], [2, 11]]
要 batch 6,每个 batch 四元,第一列说为什么:每 worker 四条目,各产一个短 batch。可迭代数据集多 worker,几个 worker replica 各以不完整 batch 结尾。所以看到的可能是几个短 batch,而不是 map 式数据集预期的一末尾短 batch。
第二个后果:drop_last=True 时 PyTorch 丢每个 worker 可迭代数据集 replica 的末尾不完整 batch。不止一个部分 batch 可能消失。
这也是 len(loader) 对某些多 worker IterableDataset 配置只是估计的原因:PyTorch 一般不知道用户定义的 worker 切片怎么把流打成 batch。假定固定 batch 的代码——reshape、硬编码维、除常数的指标——迟早在这见面。
worker 随机性与值得重查的 folklore
worker 里随机变换引出 obvious 问题:所有 worker 产出同样随机吗?
idx wid torch.randint random.randrange
[0, 0, 253906, 223507]
[1, 0, 636010, 838017]
[2, 0, 320804, 289877]
[3, 0, 768013, 59890]
[4, 1, 827724, 810954]
[5, 1, 885002, 852360]
[6, 1, 105724, 171360]
[7, 1, 32613, 673038]
本章测试的 PyTorch 2.13 实现里,worker 循环从 worker-specific state 播种 PyTorch 与 Python random,NumPy 可用时还初始化 NumPy legacy 全局 RNG。这解释上面不需自定义 worker_init_fn 的不同值。
当对实际测试实现的观察看待,别当不用想 worker 随机性的理由。PyTorch 公开可复现指南仍推荐用 worker 的 PyTorch 种子初始化流水线依赖的随机数发生器。
耐用的规则是:
知道流水线实际用哪些随机发生器,可复现重要时把它们的 worker-specific 初始化显式化。 这样重跑同样 loader 改
random列,不修 duplication bug,因为本来就没有。
别读成“播种管好了”。读成:PyTorch 播种的发生器集合特定,集合外的发生器归你管。带自己内部 RNG 的图像库、NumPy Generator 对象、独立播种的 C 扩展、第三方增强包可能在你控住的随机发生器外。
结果失败不总相同增强。可能是重复流、意外相关、跑不可复现,或种子交代不清的随机。
检查直接:样本旁边发变换随机产出的东西,按 worker_id 比。两 worker 不同下标报同样值,那个发生器没按 worker 播种。
跨跑可复现是另一轴,传显式 generator 控:
g = torch.Generator()
g.manual_seed(1234)
loader = DataLoader(dataset, batch_size=64, num_workers=4, generator=g)
相关随机由这个 generator 控、worker-local generator 正确初始化的流水线,连续 epoch 走不同随机 state,重复跑从同样可复现 setup 开始。
这不自动让整个训练 run 确定。外部随机发生器、输入顺序、非确定核与别的非确定源还要分别控。
性能上也有在乎的理由。增强流水线每次跑抽不同随机流时比 loader 配置,是在比两个 workload,归到 prefetch_factor 的计时差可能是恰好抽了很多贵增强的 run 与没抽的 run 之差。
主机到设备与诚实计时
前面在任何机器跑。这节讲 CUDA,写法让没 GPU 也推理得住。
batch 在训练进程存在后,还得到加速器。pin_memory=True 让 DataLoader 把认得的 CPU 张量放页锁定主机内存,主机到 CUDA 传输能快。
两种异步分开。
non_blocking=True 能在传输发出后免主机侧同步,即使源从普通 pageable 内存开始。
真正让主机到设备拷贝与 GPU 核执行重叠是更强的断言。当前 PyTorch 指南认三要件:pinned 源内存、有 DMA 能力的硬件、在单独非默认 CUDA 流上调度传输。
避开“这让训练更快”的断言。三个独立问题决定它能不能:
- 主机到设备拷贝占步的有意义比例吗? 读解码 50ms、拷贝 2ms,完美拷贝优化买 4%,“为什么
pin_memory没用”的答案是本来就没东西可赢。 - batch 是受益的形态吗? pin 作用于 loader 产的张量。含 Python 对象、主进程整理后建的张量的 batch 可能根本没 pin。
- schedule 允许重叠吗? 人们跳过的是这个。
第三点:non_blocking=True 让拷贝发出不 block 主机,但读张量的东西跑之前拷贝总得完。紧接着前向用拷好的 batch,依赖强制等,异步拷贝什么都没重叠。有用重叠要传输在途时有独立 work 可干——经典安排是算 batch N 前发出 batch N+1 的拷贝。
batch inspector 直接回答问题 2:
def inspect_batch(batch, prefix="batch"):
if torch.is_tensor(batch):
pinned = batch.is_pinned() if batch.device.type == "cpu" else None
print(f" {prefix:12s} shape={tuple(batch.shape)} dtype={batch.dtype} "
f"device={batch.device} pinned={pinned}")
elif isinstance(batch, dict):
for k, v in batch.items():
inspect_batch(v, f"{prefix}.{k}")
elif isinstance(batch, (list, tuple)):
for i, v in enumerate(batch):
inspect_batch(v, f"{prefix}[{i}]")
else:
print(f" {prefix:12s} {type(batch).__name__} (not a tensor)")
batch.x shape=(4, 3) dtype=torch.float32 device=cpu pinned=False
batch.id shape=(4,) dtype=torch.int64 device=cpu pinned=False
batch.name[0] str (not a tensor)
输出来自无加速器的参考机,说明另一半。要 pin 的机器上没设备拿到的是警告与没 pin 的张量:
UserWarning: 'pin_memory' argument is set as true but no accelerator is found,
then device pinned memory won't be used.
name 字段也值得一瞥:默认整理把字符串列表变成字符串列表而不是张量。它不 pin,不可传输,每 batch 悄悄带着走。
CUDA 代码周围的 wall-clock 会撒谎
这比任何 loader 设置都重要,因为它让测量无效而不只是变差。
CUDA 核 launch 相对主机常异步。CUDA 代码周围天真 wall-clock 区间不一定测设备 work 完成。可能主要测主机 launch 时间,外加恰好在测量区里的同步。
start = perf_counter()
output = model(x) # returns as soon as the kernels are queued
print(perf_counter() - start)
两正确做法,测的东西不同。
测含设备 work 的主机可见区间,两端同步:
torch.cuda.synchronize()
start = perf_counter()
output = model(x)
torch.cuda.synchronize()
elapsed = perf_counter() - start
测 CUDA 流上两点间流逝时间,用 CUDA event。event 记进流,设备打时间戳:
def time_cuda(fn):
start = torch.cuda.Event(enable_timing=True)
end = torch.cuda.Event(enable_timing=True)
start.record()
fn()
end.record()
torch.cuda.synchronize() # wait until `end` has actually occurred
return start.elapsed_time(end) # milliseconds
区别不是 pedantry。带同步的 perf_counter 告诉你流逝 wall-clock,含主机侧 Python、launch 开销与排队。CUDA event 告诉你流上两点间设备侧时长。两者大幅不一致,主机与设备时间线在讲不同故事。
差异可反映主机 launch 开销、调度、同步、排队或重叠。别把数值 gap 直接当某类 work 的测量解读。
对 measure() harness,这意味着一件事:消费者在 CUDA 上跑,t2 时间戳前同步,否则“work”列测的是 Python 排核多快,每 batch 看似一毫秒内算完而循环神秘不加速。
profiling 在简单测量之后
PyTorch profiler 真有用,也是错的第一个工具。没检查的训练循环的 trace 是关于还没问的问题的大量信息。work 的顺序是:
simple timing → identify the suspicious boundary → decompose that stage
→ profiler when you need finer attribution
真用它时,range 名按心智模型取,timeline 变成关于已理解系统的证据:
from torch.profiler import profile, record_function, ProfilerActivity
activities = [ProfilerActivity.CPU]
if torch.cuda.is_available():
activities.append(ProfilerActivity.CUDA)
with profile(activities=activities) as prof:
it = iter(loader)
for step in range(20):
with record_function("data_wait"):
x, y = next(it)
with record_function("host_to_device"):
x = x.to(device, non_blocking=True)
y = y.to(device, non_blocking=True)
with record_function("forward"):
logits = model(x)
loss = loss_fn(logits, y)
with record_function("backward"):
loss.backward()
with record_function("optimizer"):
optimizer.step()
optimizer.zero_grad(set_to_none=True)
print(prof.key_averages().table(sort_by="self_cpu_time_total", row_limit=20))
五名字就是本章开头图的阶段。这样 label 的 trace 直接回答“哪个阶段”,这正是来的目的。
在输入流水线上用 AI
让助手要快 DataLoader 配置,会得到一个。大概长这样,可能很优秀:
DataLoader(dataset, batch_size=128, num_workers=8, pin_memory=True,
prefetch_factor=4, persistent_workers=True)
worker sweep 已说明这种推荐不能从样子 judge。单核 CPU-bound 生产者上 worker 数上去端到端吞吐 450 样本每秒左右,可见 batch 等待降了,batch 后步时间大涨。等待也 burst 得多。
这足够证据拒绝“worker 越多越好”对这个流水线。本章没确立建议配置里别的选项——大 batch、深预取、pin、持久 worker——会同样效果,那些还是 separate 假设去测。建议没错。它回答的是典型流水线的问题,问的是还没确立自己哪阶段 limiting 的人。
管用的动作是本书一直用的:先让助手产出你程序的可证伪模型,再产出配置。
Here are measurements from a PyTorch training run. Do not recommend a
configuration yet.
batch size / num_workers / prefetch_factor / persistent_workers / pin_memory
mean, median, p95 and max next(loader) wait
mean post-batch step time
end-to-end examples/sec
CPU utilization, core count, and whether workers call threaded libraries
RAM and shared-memory usage
device, and host-to-device time if measured
whether these are steady-state numbers or include startup
1. Which stage is the strongest bottleneck hypothesis, and which specific
numbers support it?
2. Give two alternative explanations that would produce similar symptoms.
3. Propose the smallest experiment that distinguishes the leading explanation
from those alternatives. It should change one mechanism.
4. State what each measurement should do if the leading hypothesis is correct,
and what it should do if each alternative is correct instead.
I will run the experiment and report the numbers. Only then propose a change.
第 4 点把交流从建议变成科学,因为它让助手的模型错得可检测。“加 num_workers 看看”不可证伪——任何结局事后都圆得上。“latency-bound 生产翻倍 worker 平均等待大致减半而步时间不动;CPU-bound 平均等待降而步时间涨、样本每秒平”是对本章顶部两张表九十秒定案的预测。
先要程序的可证伪模型,再要重写的配置。
这里有个值得点名的 specific 陷阱。助手擅长旋钮,弱在 IterableDataset 切分对不对,因为 duplication bug 在源码里不像 bug。问旋钮得到旋钮。问“这个数据集一 epoch 该含多少唯一样本,四 worker 下什么代码保证”,问题有可检查的答案。
你现在应该能回答什么
这里有会被递到手里的流水线。它跑,损失下降,有人已调过。先自己走一遍再往下读。
class Shards(IterableDataset):
def __init__(self, paths):
self.paths = paths
self.seen = 0
def __iter__(self):
for path in self.paths:
for record in read_records(path): # ~0.5 ms, mostly disk wait
self.seen += 1
yield augment(decode(record)) # ~3 ms of CPU
loader = DataLoader(Shards(paths), batch_size=64, num_workers=8,
prefetch_factor=4, persistent_workers=True,
pin_memory=True)
for epoch in range(20):
for x, y in loader:
train_step(x.to("cuda", non_blocking=True))
print(f"epoch {epoch}: {loader.dataset.seen} records seen")
一 epoch 多少唯一样本? 不是文件内容算出的数。__iter__ 无 worker awareness,八 worker 各迭代每 shard,epoch 里数据集八份。损失会降,epoch 花的时间 plausible,什么都不抛。
seen 计数器打印什么? 每 epoch 零。self.seen 在 worker replica 里加,loader.dataset 是主进程原对象,worker 从没碰。这正是持久化实验的效果:父的 .calls 零而 worker 数到十二。
persistent_workers=True 改那个计数器吗? 主进程里不改。它让 worker 自己的计数器跨 epoch 累积而不是重置,这里看不见,正是持久化是语义决定而不是性能决定的那种 worker-local state。
num_workers=8 合理吗? 从代码 unknown,每样本代价说要测而不是 assumed。生产约 0.5ms 等待加 3ms CPU。CPU 重部分意味着可用 CPU 容量终究 limit 扩展,0.5ms 等待成分意味着一些额外并发仍可能有用。
worker 何时开始与训练进程 destructive 地争,代码读不出。worker sweep 正为这个。定案的证据是同时记样本每秒、等待百分位与 batch 后步时间的 sweep。
prefetch_factor=4 买到什么? 八 worker、prefetch_factor=4,PyTorch 允许消费前跨 worker 预取最多 32 batch。
这是 DataLoader 配置预取深的陈述,不是同时活着的每个 batch 对象、中间分配或字节的精确计数。生产 latency 稳,本章测量说这个深相对 2 什么都不买还花内存。shard 边界造成周期 stall——开新文件、解压开始——深队列盖住真方差,内存花得值。大 p95-median gap 是 batch 可用 bursty 的证据。它本身不证明加深队列去因;那还是实验。
pin_memory=True 在帮忙吗? 三检查,没有一个是“它开了”。is_pinned() 确认 batch 真 pin。event 或两端同步测主机到设备拷贝占步的有意义比例。确认测的 benefit 是什么。这个循环里 batch 的前向算必须等这个 batch 的传输可用,所以这个循环没展示流水化 GPU 拷贝/计算重叠。
non_blocking=True 仍可能降主机侧同步开销。测真拷贝/计算重叠要显式流水 schedule——通常在独立计算 batch N 时在恰当单独 CUDA 流上传未来 batch——再测端到端。
循环慢先测什么? 拆步。next() 的等待与之后的时间都记,丢 warmup,mean、median、p95、max 留着。第一次测量告诉你 batch 到达边界哪边当前主导可见步:等下一 batch,还是 batch 到达后的 work。
后边主导还要拆——主机到设备传输、CPU 侧训练代码、前向、反向、优化器与同步是不同可能 limit,剩下调查全取决于哪个 true。
等待 40ms、步 12ms,下个实验是什么? 不是再加八 worker。用 num_workers=0 复现拿到无并发生产代价,再拆:读、解码、增强、整理。每样本 3ms CPU 对 0.5ms 等待说代价大头在 decode 与 augment,decode 确定与否决定预计算或缓存输出是不是候选。值不值再看存储代价、缓存大小、失效与剩下流水线。
worker epoch 3 exited unexpectedly 死、epoch 1 从不死,提示什么? 累积的 worker-local state 成为强假设,尤其 persistent_workers=True,但不是唯一解释。靠后样本、外部服务失败、非确定 native 崩溃能有类似 timing。
设 persistent_workers=False 测累积假设,看失败移动或消失。同进程活了三 epoch,worker-local state——长大的缓存、从不关的句柄、从不释放的内存——强候选。再逐个降 num_workers、prefetch_factor、batch_size,三者都推在途内存,容器里查 /dev/shm 大小。
什么证据证明修复 work? 稳态端到端样本每秒,固定 batch 数,等待分布与 batch 后步时间陪着。平均等待降不够——spin 表等待比减半而什么都没办成。而切片修复的证据是计数:每 epoch 唯一样本等于数据集大小,不止一个 worker 数下成立。
练习
这些是用来跑的,对应本章配套 notebook。
- 标定再复现两曲线。 测你机器的
ITERS_PER_MS,再对sleep与spin生产者跑 worker sweep。跑之前用核数与本章算术预测每曲线哪停。报告预测错在哪、为什么。 - 找交叉。 建每样本代价里 sleep 占比例 f、spin 占剩下的生产者。f 从 0 扫到 1,每值找吞吐不再涨的 worker 数。画该数对 f 并解释形状。
- 让等待比撒谎。 构造等待比好至少 30%、样本每秒不变或更差的配置变化。再写两行总结,发给把改进当 win 报告的同事。
- 启动 vs 稳态。 worker 0 到 8 测首 batch 与稳态 batch 时间。再算 20、200、20000 batch 的 job 各总 wall-clock、谁赢。解释答案为何变。
- 复制一 epoch。 文本文件上写
IterableDataset,2、3、4 worker 下数唯一确认复制。再用get_worker_info()修。再用连续切片第二种修,说出顺序数据用哪个、为什么。 - 短 batch。 切片可迭代数据集 100 条目、4 worker 要
batch_size=64,记每 batch 实际大小。解释分布。再找自己写过的训练循环里会在它上面坏的一行。 - 两次崩溃,两流程。 建特定下标抛 Python 异常的数据集一、worker 不抛就死的二。每个
num_workers=4再0跑,记四跑各学到什么。写下下次走的决策流程。 - 持久 state。 给数据集 worker-local 随样本长的缓存,
persistent_workersFalse与True各跑五 epoch,记每 epoch 时间与进程内存。找出持久化不再省的 epoch。 - 先错 profile。
__getitem__便宜、collate_fn贵的流水线拿来。单独 profile__getitem__记下会得出的结论。再测整 batch 生产时间并解释差。 - 审计没写过的流水线。 仓库里拿
DataLoadersetup。不改回答:等待分布什么样,batch 后步时间多少,每 epoch 样本数在不止一个 worker 数下对上数据集大小吗,哪个设置有测量证据。
下一步:batch 里是什么?
流水线现在是系统而不是函数调用。有东西产出样本,有东西打成 batch,worker 进程可能并发准备未来 work,备好的 batch 在队列等,训练循环消费。看起来像调参的每个参数是其中某阶段的性质,每阶段单独可测。
更有用的是失败模式有了地址。慢流水线是跟不上的阶段,worker sweep 加等待分布告诉你哪个。崩溃流水线是坏样本或坏边界,num_workers=0 一跑区分。不变好只变快的流水线是测量动了而不是系统变了,端到端样本每秒定案。加并发改含义的流水线是划分 bug,数唯一不看损失曲线找。
还剩一个假设站着,本章一直靠它没检查。每测量把 batch 当交付单位:有大小、有代价、有到达时间。Producer 返回 torch.randn(128) 与随机标签,内容与何时到无关。
真实样本不是随机数。它们是解码过的文件、转换过的值、resize 过的数组、对着某处算的统计归一过的张量,这 epoch 与上 epoch 增强可能不同的图像。每步都是数字含义的决定,每步都能错成形状、dtype、设备完全正确的张量。
第 6 章问 batch 为什么晚。下一章问同一 batch 更难的问题:里面张量实际表示什么,是模型要收的东西吗?
batch 意味着什么。