1. 从“总指挥”到“插件化”:Runner与Hook的协同哲学
如果你用过PyTorch的原生训练循环,肯定写过类似的代码:一个for循环套着另一个for循环,里面是前向传播、计算损失、反向传播、参数更新。代码写起来简单直接,但当你想要加入学习率调整、模型保存、日志记录、验证集评估这些功能时,代码就会迅速膨胀,变得又长又乱,各种逻辑耦合在一起,改起来心惊胆战。
MMDetection(或者说其底层的MMCV)的Runner和Hook机制,就是为了解决这个痛点而生的。你可以把Runner想象成训练流程的“总指挥”或“交响乐团的指挥家”。它手里有一份标准的乐谱(训练流程),知道什么时候该开始一个乐章(epoch),什么时候该进入一个小节(iteration)。但是,光有指挥不行,乐团还需要各种乐器(功能模块)来演奏。Hook就是这些乐器,它们不是乐谱本身,而是在乐谱的特定节拍点(比如每个小节开始前、结束后)插入自己的演奏。
这种设计带来的最大好处就是解耦和灵活。Runner只负责按部就班地推进训练的生命周期,它定义好了“before_run”、“after_train_iter”、“after_val_epoch”等一系列关键的时间节点(我们称之为“钩子点”)。而具体的功能,比如保存模型、记录日志、调整学习率,都被封装成一个个独立的Hook。你需要什么功能,就把对应的Hook“挂”到Runner上。Runner在运行到每个钩子点时,就会大喊一声:“喂,挂在这个点上的所有Hook,该你们上场表演了!” 然后所有注册到这个点的Hook就会按照优先级依次执行自己的逻辑。
我刚开始接触时觉得有点绕,但用多了才发现真香。这意味着你的训练主流程(Runner)代码可以保持极其简洁和稳定,而所有定制化、实验性的功能,都可以通过编写或配置Hook来实现,彼此之间互不干扰。你想试试新的学习率策略?写一个LrHook。想每100个iteration可视化一下特征图?写一个VisualizationHook。完全不用去动Runner的核心循环代码。这种“事件驱动”的编程模型,让整个训练框架变得像乐高积木一样,可拼插、可扩展。
2. 深入Runner:训练生命周期的“总导演”
Runner不是一个玄乎的概念,在MMCV中,它就是一个实实在在的Python类。最常用的是 EpochBasedRunner 和 IterBasedRunner,顾名思义,一个按epoch来管理训练轮次,另一个按iteration(迭代次数)来管理。对于目标检测这类任务,我们通常使用 EpochBasedRunner。
2.1 Runner的四大核心职责
Runner的构造函数就像是一个项目的启动会,它需要接收并整合所有必要的资源:
# 一个简化的Runner初始化场景
runner = Runner(
model=your_detection_model, # 你的模型,比如Faster R-CNN
optimizer=dict(type='AdamW', lr=0.0001), # 优化器配置
work_dir='./work_dirs/exp1', # 工作目录,存放日志和模型
logger=logger, # 日志记录器
meta=dict(seed=42, exp_name='my_exp') # 一些元信息
)
初始化之后,Runner就准备好了舞台。它的核心工作流程,主要体现在四个关键方法上:run(), train(), val(), save_checkpoint()。其中,run() 是最高层的调度入口。
2.2 run() 方法:工作流的调度器
run() 方法是整个训练脚本的引擎。它接收两个关键参数:data_loaders(数据加载器列表)和 workflow(工作流定义)。workflow 这个参数的设计非常巧妙,它让你能用一种声明式的方式定义复杂的训练-验证交替策略。
举个例子,这是最常见的配置:
# 训练12个epoch
runner.run(data_loaders=[train_loader, val_loader],
workflow=[('train', 12)], # 只训练,不中途验证
max_epochs=12)
但如果你想每训练2个epoch就验证1次,可以这样:
# 总epoch数为12,但以 [训练2epoch -> 验证1epoch] 为一个循环,执行4次。
runner.run(data_loaders=[train_loader, val_loader],
workflow=[('train', 2), ('val', 1)], # 先训练2轮,再验证1轮
max_epochs=12)
run() 方法内部就是一个大循环,它会根据 workflow 的描述,反复调用 train() 或 val() 方法。IterBasedRunner 的逻辑类似,只是把 epoch 换成了 iter。这种设计把训练流程的宏观节奏控制权完全交给了配置,非常清晰。
2.3 train() 与 val():一个epoch的微观循环
当 run() 决定要执行一个训练epoch时,就会调用 train() 方法。我们深入看一下 train() 的简化版核心逻辑:
def train(self, data_loader, **kwargs):
self.model.train() # 切换到训练模式
self.mode = 'train'
self.data_loader = data_loader
# 调用钩子:一个epoch开始啦!
self.call_hook('before_train_epoch')
for i, data_batch in enumerate(data_loader):
self._inner_iter = i
# 调用钩子:一个iteration开始啦!
self.call_hook('before_train_iter')
# 核心三步曲:前向、损失、反向传播(在model.train_step中完成)
outputs = self.model.train_step(data_batch, self.optimizer, **kwargs)
# 调用钩子:一个iteration结束啦!
self.call_hook('after_train_iter')
self._iter += 1
# 调用钩子:一个epoch结束啦!
self.call_hook('after_train_epoch')
self._epoch += 1
看,这就是Runner作为“总导演”的剧本。它严格定义了在一个epoch内,事情发生的顺序:epoch开始 -> 循环每个batch -> batch开始 -> 执行模型更新 -> batch结束 -> epoch结束。在每个箭头所指的关键时刻,它都留出了一个“插口”,这就是 call_hook(fn_name)。val() 方法的流程几乎镜像,只是调用了 model.val_step() 且不计算梯度。
2.4 save_checkpoint():状态的快照师
这个方法相对独立,但至关重要。它负责将训练过程中的完整状态保存下来,形成一个“.pth”或“.ckpt”文件。一个完整的checkpoint通常包括:
meta: 环境信息,如当前的epoch数、iter数、配置信息等。state_dict: 模型的所有可学习参数。optimizer: 优化器的状态(对于Adam等有动量的优化器,恢复训练必须要有这个)。- 其他:有时还会保存如学习率调度器的状态。
Runner通常不直接调用这个方法,而是由一个专门的 CheckpointHook 来负责在合适的时机(比如每隔N个epoch后)调用它。这再次体现了单一职责原则:Runner负责流程,Hook负责具体功能。
3. 剖析Hook:事件驱动的“插件模块”
如果说Runner是骨骼,那Hook就是肌肉和神经。Hook机制的精髓在于事件驱动。Runner在生命周期中抛出各种事件,而Hook则监听自己关心的事件,并在事件发生时执行代码。
3.1 Hook的基类与生命周期
所有Hook的起点都是 mmcv.runner.Hook 这个基类。它极其简单,只定义了几个空方法,对应着Runner生命周期中的各个事件点:
class Hook:
def before_run(self, runner): pass # 整个训练开始前
def after_run(self, runner): pass # 整个训练结束后
def before_train_epoch(self, runner): pass # 每个训练epoch开始前
def after_train_epoch(self, runner): pass # 每个训练epoch结束后
def before_train_iter(self, runner): pass # 每个训练iteration开始前
def after_train_iter(self, runner): pass # 每个训练iteration结束后
# 还有对应的 before/after_val_epoch, before/after_val_iter
你想创建一个自定义Hook?很简单,继承这个类,然后重写你感兴趣的方法。比如,你想在每个iteration后打印一下当前损失,就重写 after_train_iter 方法。
3.2 Hook的优先级与执行顺序
一个关键问题是:如果有多个Hook都注册到了同一个事件点(比如 after_train_iter),谁先执行?答案是:按优先级(Priority)执行。MMCV内置的Hook有默认的优先级,数值越小优先级越高(越先执行)。
| Hook类型 | 优先级 (Priority) | 典型作用 |
|---|---|---|
| LrUpdaterHook | VERY_HIGH (10) | 更新学习率,必须在优化器更新前执行 |
| MomentumUpdaterHook | HIGH (30) | 更新动量(如SGD with momentum) |
| OptimizerHook | ABOVE_NORMAL (40) | 执行 loss.backward() 和 optimizer.step() |
| CheckpointHook | NORMAL (50) | 保存模型检查点 |
| IterTimerHook | LOW (70) | 记录每个iteration耗时 |
| LoggerHook | VERY_LOW (90) | 记录日志到文件或控制台 |
这个顺序是精心设计的。例如,LrUpdaterHook 必须在 OptimizerHook 之前运行,因为优化器step时需要用到最新的学习率。LoggerHook 通常在最后,因为它要收集本轮迭代的所有信息(包括损失、学习率、时间等)进行记录。
当你注册自定义Hook时,可以指定它的优先级。默认是 NORMAL (50)。如果和内置Hook优先级相同,则自定义Hook在内置Hook之后执行。
3.3 内置Hook详解:开箱即用的强大工具
MMDetection/MMCV提供了一系列内置Hook,覆盖了训练中的常见需求。通过配置文件,你可以轻松启用和配置它们,无需写一行代码。
CheckpointHook:你的模型存档员 这是最常用的Hook之一。配置示例:
checkpoint_config = dict(
interval=1, # 每1个epoch保存一次
save_optimizer=True, # 同时保存优化器状态,便于恢复训练
out_dir='work_dirs', # 保存路径
max_keep_ckpts=3, # 只保留最新的3个检查点,自动删除旧的
save_last=True, # 额外保存一份名为 `last.pth` 的最新检查点
by_epoch=True # 按epoch间隔保存。如果为False,则按iteration间隔
)
它主要监听 after_train_epoch 和 after_train_iter 事件(取决于 by_epoch),在满足间隔条件时调用Runner的 save_checkpoint() 方法。
LogConfig 与 LoggerHook:训练过程的记录者 日志配置稍微复杂一点,因为它可能包含多个后端(比如同时输出到终端和TensorBoard)。
log_config = dict(
interval=50, # 每50个iteration打印一次日志
hooks=[
dict(type='TextLoggerHook'), # 文本日志,输出到控制台和文件
dict(type='TensorboardLoggerHook', log_dir='./tf_logs'), # TensorBoard
# dict(type='WandbLoggerHook', init_kwargs=dict(project='mmdet')), # WandB
]
)
LoggerHook 的优先级很低(VERY_LOW),因为它需要在所有其他Hook(特别是计算损失的Hook)执行完毕后,才能收集到完整的数据进行记录。
LrConfig 与 LrUpdaterHook:学习率的指挥家 学习率调度是训练的关键。MMDetection支持多种策略,如固定步长衰减、余弦退火、多项式衰减等。
lr_config = dict(
policy='step', # 策略类型
warmup='linear', # 使用线性学习率预热
warmup_iters=500, # 预热持续500个iteration
warmup_ratio=0.001, # 起始学习率 = base_lr * warmup_ratio
step=[8, 11] # 在第8和第11个epoch时,将学习率乘以gamma(默认0.1)
)
LrUpdaterHook 会在 before_train_iter 这个高优先级事件中,根据当前的epoch或iter数,计算出最新的学习率,并通过 runner.optimizer.param_groups 更新给优化器。
4. 协同工作流全景:一个iteration的完整旅程
现在,让我们把Runner和Hook放到一起,看看在一个完整的训练iteration中,它们是如何像精密钟表一样协同工作的。假设我们配置了上述所有常见的Hook。
-
before_run:训练大幕拉开。CheckpointHook可能会打印一句“Checkpoints will be saved to...”。LoggerHook初始化日志文件。所有Hook做最后的准备工作。 -
进入一个训练epoch:
before_train_epoch:LrUpdaterHook可能会在epoch开始时检查是否需要调整学习率(对于某些策略)。LoggerHook记录epoch开始的标记。
-
进入一个训练iteration:
before_train_iter:这是最繁忙的钩子点之一。IterTimerHook启动计时器,记录这个iteration的开始时间。LrUpdaterHook(优先级10) 计算并更新当前iteration的学习率。MomentumUpdaterHook(优先级30) 如果需要,更新动量参数。
- 核心计算:Runner调用
model.train_step()。模型进行前向传播,计算损失,执行loss.backward()。注意,梯度计算在这里发生,但参数更新(optimizer.step())是由OptimizerHook控制的。 after_train_iter:另一个繁忙的钩子点。OptimizerHook(优先级40) 执行optimizer.step()更新模型参数,然后optimizer.zero_grad()清空梯度。CheckpointHook(优先级50) 检查是否达到了保存间隔(如果按iter保存),如果是,则保存模型。IterTimerHook(优先级70) 停止计时器,计算本iteration耗时。LoggerHook(优先级90) 收集本iteration的损失、学习率、耗时等信息。如果达到了日志打印间隔(如每50个iter),就将信息格式化输出到控制台和日志文件。同时,如果配置了Tensorboard,也会将标量数据写入事件文件。
-
结束一个训练epoch:
after_train_epoch:CheckpointHook检查是否达到了按epoch保存的间隔,如果是,则保存模型。LoggerHook可能会记录一些epoch级别的统计信息。
-
(如果workflow中有验证)进入验证阶段:流程类似,但会调用
before_val_epoch,before_val_iter,model.val_step(),after_val_iter,after_val_epoch等钩子。注意,验证阶段没有OptimizerHook和LrUpdaterHook。 -
after_run:训练全部结束。LoggerHook关闭文件,CheckpointHook可能执行最终清理,所有Hook进行收尾工作。
整个过程就像一条精心设计的流水线,Runner是传送带,控制着节奏和顺序,而每个Hook是流水线上的工人,在固定的工位(钩子点)完成自己特定的任务。这种设计使得增加、移除或替换一个“工人”(Hook)变得非常容易,而完全不影响整条“生产线”(Runner)的运转。
5. 实战:编写一个自定义Hook
理解了原理,最好的巩固方式就是动手写一个。假设我们想在训练过程中,每隔一定周期,将模型在验证集上的某几个样本的预测结果可视化并保存下来,用于定性分析模型的学习进展。
我们可以创建一个 VisualizationHook。
第一步:定义Hook类
我们在项目的某个目录下(比如 tools/custom_hooks/)新建一个文件 visualization_hook.py。
import os
import torch
from mmcv.runner import HOOKS, Hook
from mmdet.apis import inference_detector, show_result_pyplot
@HOOKS.register_module() # 关键!使用装饰器注册到HOOKS注册器
class VisualizationHook(Hook):
def __init__(self,
interval, # 可视化的间隔(单位:epoch)
val_dataset, # 验证集对象
img_indices=[0, 5, 10], # 选择验证集中哪些图片进行可视化
show=False, # 是否弹出窗口显示
out_dir='./vis_results'): # 可视化结果保存目录
self.interval = interval
self.val_dataset = val_dataset
self.img_indices = img_indices
self.show = show
self.out_dir = out_dir
if not os.path.exists(self.out_dir):
os.makedirs(self.out_dir)
def after_train_epoch(self, runner):
"""在每个训练epoch结束后判断是否需要执行可视化"""
# 如果当前epoch不是间隔的整数倍,则不执行
if not self.every_n_epochs(runner, self.interval):
return
epoch = runner.epoch
print(f'Visualizing at epoch {epoch}...')
# 1. 将模型设置为评估模式
runner.model.eval()
with torch.no_grad():
for idx in self.img_indices:
# 2. 获取验证集中的一张图片和其信息
data_info = self.val_dataset[idx]
img_path = data_info['filename']
# 假设数据集返回的是路径,需要读取图片
# 实际中可能需要根据数据集类做调整
img = mmcv.imread(img_path)
# 3. 进行推理
result = inference_detector(runner.model, img)
# 4. 可视化并保存结果
out_file = os.path.join(self.out_dir, f'epoch_{epoch}_idx_{idx}.jpg')
show_result_pyplot(img,
result,
self.val_dataset.CLASSES, # 类别名称
show=self.show,
out_file=out_file)
# 5. 恢复模型为训练模式
runner.model.train()
第二步:在配置文件中导入并使用
首先,需要确保Python能找到你的Hook。一种简单的方法是在配置文件中通过 custom_imports 导入。
custom_imports = dict(imports=['tools.custom_hooks.visualization_hook'], allow_failed_imports=False)
# 然后在配置文件的 `custom_hooks` 部分添加
custom_hooks = [
dict(type='VisualizationHook',
interval=5, # 每5个epoch可视化一次
val_dataset=val_dataset, # 这里需要传入实际的验证集对象,通常在配置文件中通过数据管道构建
img_indices=[0, 2, 4],
show=False,
out_dir='work_dirs/vis')
]
注意:这里有一个技术细节,val_dataset 通常是在运行时构建的,直接写在静态配置里可能不行。更稳健的做法是在Hook的 before_run 方法中,通过 runner.data_loader 来获取验证集数据。这里为了示例清晰做了简化。
第三步:理解执行时机
这个Hook注册到了 after_train_epoch 事件点。这意味着在每个训练epoch结束后,Runner都会调用它。Hook内部的 every_n_epochs 方法(继承自基类Hook)会检查当前epoch是否符合间隔条件,符合则执行可视化逻辑。
通过这个例子,你可以看到,自定义Hook让你能够以非侵入式的方式,将任何你想要的监控、调试、辅助功能插入到训练流程中,极大地增强了实验的灵活性和可观察性。这正是Runner+Hook这套协同工作流最强大的地方。
1004



被折叠的 条评论
为什么被折叠?



