编排层:谁负责把零件装起来

配置、数据、模型、优化器都有了。它们各自不认识对方,需要有个东西把它们装在一起。

这个东西通常叫 LoadAll 或者 Runner。

它为什么必须存在

先看没有它会怎样。

看训练脚本的入口:

if __name__ == "__main__": cfg = setting() load = LoadAll(cfg) # ← 就这一行 load.run()

入口只有三行。所有"装配"的复杂度被压在 LoadAll 里。

如果不用编排层

入口会长成什么样

入口自己装配

先读配置 → 建 dataset → 建 dataloader → 建 model → 搬到 device → 建 optimizer → 建 scheduler → 检查有没有 checkpoint → 有就加载 → 建 tensorboard writer → 建训练器…… 全部堆在 main 里

30 行装配代码堆在入口,等于没有结构。

它做四件事

阶段

做什么

建数据

调 predata,得到训练集 / 验证集 / DataLoader

建模型

用配置里的名字查注册表,实例化,搬到 device

建训练组件

optimizer、scheduler、loss

恢复现场

有 checkpoint 就加载,拿到 start_epoch 和 best_acc

一份真实的实现

职责清楚了,看代码。

class LoadAll: def __init__(self, cfg): self.cfg = cfg # 这些先占位,后面某一步会填上 self.optimizer = None self.scheduler = None self.start_epoch = 0 # 续训时会被 checkpoint 改掉 self.best_acc = 0 # 续训时也要接着用 self.checkpoint = None def build_model(self): build = get_model(self.cfg.model_name) # 查注册表 self.model = build(self.cfg) def build_optim(self): self.optimizer = torch.optim.AdamW( self.model.parameters(), lr=self.cfg.lr ) self.scheduler = torch.optim.lr_scheduler.CosineAnnealingLR( self.optimizer, T_max=self.cfg.epochs ) def resume(self): # 有断点就接着训 if self.cfg.resume_path and Path(self.cfg.resume_path).exists(): self.checkpoint = torch.load(self.cfg.resume_path, map_location=self.cfg.device) self.model.load_state_dict(self.checkpoint["model_state_dict"]) self.optimizer.load_state_dict(self.checkpoint["optimizer_state_dict"]) self.scheduler.load_state_dict(self.checkpoint["scheduler_state_dict"]) self.start_epoch = self.checkpoint["epoch"] + 1 self.best_acc = self.checkpoint["best_acc"] def switch(self): # 把该搬的都搬到设备上 self.model = self.model.to(self.cfg.device) def run(self): self.build_data() # 见下一课 self.build_model() self.switch() self.build_optim() self.resume() Trainer(self)(self.train_loader, self.val_loader)

resume 必须在 build_optim 之后

optimizer.load_state_dict 要求优化器已经建好。

顺序错了会报 ValueError: loaded state dict contains a parameter group that doesn't match。

为什么要拆成好几个方法

上面每个方法都很短,看起来可以合并。分开写是有代价的,也是有好处的。

全塞进 __init__ 也能跑。拆开的理由:

好处

具体

能单独测

只调 build_model() 看模型对不对,不跑训练

能改顺序

想先冻结部分层再建优化器,改动很小

报错定位准

崩在 build_optim 还是 resume,一眼看出

能做实验

写个脚本只调 build_data(),看看数据长什么样

另一种写法:依赖注入

上面的 LoadAll 自己 new 出所有东西,拿到手就已经齐了。

另一种思路是"你给我什么我就用什么":

class Trainer: def __init__(self, model, optimizer, scheduler, cfg): self.model = model self.opt = optimizer self.sch = scheduler self.cfg = cfg # 装配在外面做 model = get_model(cfg.model_name)(cfg).to(cfg.device) opt = torch.optim.AdamW(model.parameters(), lr=cfg.lr) trainer = Trainer(model, opt, scheduler, cfg)

LoadAll(自己建)

依赖注入(外面给)

入口长度

短(3 行)

长(6-8 行)

替换零件

要改 LoadAll

外面换一个传进去就行

测试

要构造完整 cfg

传个假模型就能测

适合

项目固定、不常换零件

组件要被复用

实际项目里两种都有

LoadAll 适合"一个项目一套流程"。

依赖注入适合"训练器要能配任意模型"的库(PyTorch Lightning、HuggingFace Trainer 都是这种)。

自己写项目,LoadAll 更省事。

编排层不该做的事

编排层的边界最容易糊。列一下它不该碰什么。

不该

为什么

写训练循环

那是 train/ 的事

定义网络结构

那是 model/ 的事

做数据增强

那是 predata/ 的事

算指标

那是训练器的事

它只做装配 + 恢复现场。判断方法:这一层里有没有循环? 有循环就说明它在干活,不是编排。

下一课

装配到最后一步是"有没有上次的训练可以接着跑"。下一课专门讲断点续训。