Hugging Face 开源 MMDP:多模态数据管道优化方案,解决 GPU 闲置与填充浪费
Hugging Face 团队发布高效多模态数据管道(MMDP),旨在解决训练过程中因数据加载瓶颈导致的 GPU 闲置和内存填充浪费问题。该工具通过优化批处理策略和数据流架构,显著提升 nanoVLM 等模型的训练效率,并已在 GitHub 开源供开发者复用。
报道正文
本文目录13 个章节
高效多模态数据流水线
发布于 2025 年 7 月 8 日 在 GitHub 上更新 点赞 74
Aritra Roy Gosthipaty ariG23498 Luis lusxvr Andres Marafioti andito Sergio Paniego sergiopaniego Pedro Cuenca pcuenq
你已经万事俱备——数据、模型,还有强大的 GPU 配置。你点击“运行”,然后……等待。继续等待。你的 GPU 几乎没怎么发力,而你的钱包却在每小时变轻。
听起来很熟悉?我们也经历过这种情况。在我们的 nanoVLM 项目中进行了一些排查工作后,我们 发现真正的罪魁祸首既不是我们的模型也不是硬件,而是极其浪费的数据流水线。
以下是我们发现的问题:
在这篇文章中,我们将通过 五个阶段 构建一个高效的流水线。在每个阶段,我们会在前一步的基础上增加或移除某些内容,并评论哪些地方做对了,哪些地方没有。
目录:
[阶段 0] 准备工作
为了让数据准备任务更易于跟随,我们创建了一个独立的仓库,专门聚焦于数据流水线本身。我们希望这比阅读集成到 nanoVLM 仓库中的代码更容易理解。此外,这也可能有助于引导其他数据流水线的开发!
代码仓库:https://github.com/ariG23498/mmdp
要跟随本文操作,你只需克隆该仓库。仓库中包含了最终的数据准备任务,但其设计初衷是逐步展示每个环节。
$ git clone https://github.com/ariG23498/mmdp.git[阶段 1] 数据集可视化
在进行任何优化之前,我们需要先了解手头的数据。我们的多模态数据集包含图像、文本提示(prompts)和响应。
$ uv run 01_check_dataset.py熟悉训练数据对于成功至关重要。上述脚本每次运行都会显示一个随机样本;你可能希望将该代码片段复制到 notebook 中并多次运行,以更好地感知数据分布。
[阶段 2] 朴素填充(Naive Padding)
我们首次尝试训练时采用了显而易见(且非常常见)的方法:
- 对所有数据进行分词(Tokenize)
- 找出每个批次中最长的序列
- 将其他所有序列填充至相同长度
$ uv run 02_naive_pad_dataloader.py结果令人痛苦。请看这张可视化图:
看到那些灰色区域了吗?那就是填充部分。这意味着 GPU 正在处理毫无意义的内容,而你却在为此支付算力成本。我们大约浪费了 60% 的批次容量在空 token 上。
[阶段 3] 受限填充(Constrained Padding)
我们的下一步很简单:设定一个全局最大长度并严格遵守。如果某个样本过长,就直接丢弃它。
你可能已经注意到,现在的批次少了一个样本。这是由于过滤过程导致的。这种方法有所改进,但我们仍然将所有内容填充到相同的固定长度,而不管实际内容如何。虽然比之前好,但依然存在浪费。
[阶段 4]:利用背包算法进行更智能的打包
现在,我们准备好彻底重新思考批处理了。填充(padding)是敌人,我们需要一种策略来最小化它,同时最大化每个批次能容纳的数据量。这时,背包问题 登场了——这是计算机科学中的一个经典问题,非常适合解决这一难题。
想象一下,你正在为徒步旅行打包背包。背包只能承受一定的重量,而你希望尽可能多地装入有用的物品。在我们的场景中:
- 背包 是一个具有最大 token 限制(
max_length)的训练批次。 - 每个 物品 是一个序列(一个经过分词处理的 prompt-response 对),其 重量 是该序列的 token 数量。
- 我们的目标是在不超过 token 限制的前提下,将尽可能多的序列装入批次中,从而最小化空间浪费。
为了验证这一想法,我们从一个小数据集开始:仅包含从 1 到 25 的数字列表,每个数字代表一个序列的长度。这让我们能够在不涉及图像和文本复杂性的情况下进行实验。
切换到可迭代数据集
大多数 PyTorch 数据集都是 map-style(通过 dataset[i] 访问)。但对于动态批处理,我们需要更灵活的机制。因此,我们通过继承 torch.utils.data.IterableDataset 构建了一个 iterable-style 数据集。这允许我们在运行时生成批次,并处理诸如在多 worker 之间分片数据等技巧:
def _get_data_range(self):
worker_info = get_worker_info()
if worker_info is None:
return self.start, self.end
else:
per_worker = int(
math.ceil((self.end - self.start) / worker_info.num_workers)
)
worker_id = worker_info.id
iter_start = self.start + worker_id * per_worker
iter_end = min(iter_start + per_worker, self.end)
return iter_start, iter_end生产者-消费者魔法
打包序列可能会很慢,尤其是在排序或打乱顺序时。为了保持流程顺畅,我们使用 Python 队列 实现了 生产者-消费者 模式:
def _producer(self, data_iter, queue, stop_signal):
if self.strategy == "greedy":
for pack in self._greedy_packing(data_iter):
queue.put(pack)
elif self.strategy == "binpack":
while True:
buffer = list(itertools.islice(data_iter, self.buffer_size))
if not buffer:
break
knapsacks = self._bin_packing(buffer)
for pack in knapsacks:
queue.put(pack)
queue.put(stop_signal)生产者线程负责打包批次并将其放入队列,而主线程则按需从中取出。这种重叠机制使流水线能够保持流畅运行。
贪心打包
首先,我们尝试一种简单的 贪心打包 策略:
def _greedy_packing(self, iterator):
pack, pack_sum = [], 0
for item in iterator:
if item > self.max_length:
continue
if pack_sum + item <= self.max_length:
pack.append(item)
pack_sum += item
else:
yield pack
pack = [item]
pack_sum = item
if pack:
yield pack该策略按顺序遍历数据,将项目添加到包中直到装满,然后开始新的包。这种方法速度快但并不完美。以下是生成的批次示例:
=== Strategy: GREEDY ===
[tensor([1]), tensor([2]), tensor([3]), tensor([4]), tensor([5]), tensor([6]), tensor([7]), tensor([8]), tensor([9]), tensor([10]), tensor([11]), tensor([12]), tensor([13])]
[tensor([14]), tensor([15]), tensor([16]), tensor([17]), tensor([18]), tensor([19])]
[tensor([20]), tensor([21]), tensor([22]), tensor([23])]
[tensor([24])]请注意后面的批次变得多么稀疏?我们留下了空隙。
装箱算法以实现更紧凑的填充
让我们尝试一种更智能的方法:装箱问题(具体来说是“首次适应递减”算法):
def _bin_packing(self, buffer: List[int]):
buffer = sorted(buffer, reverse=True)
knapsacks = []
for item in buffer:
for pack in knapsacks:
if sum(pack) + item <= self.max_length:
pack.append(item)
break
else:
knapsacks.append([item])这会将序列按长度排序(最长的优先),并尝试将每个序列放入第一个有足够空间的“包”中。如果没有合适的包,则开始一个新的包。结果如下:
=== Strategy: BINPACK ===
[tensor([24]), tensor([23]), tensor([22]), tensor([21]), tensor([10])]
[tensor([20]), tensor([19]), tensor([18]), tensor([17]), tensor([16]), tensor([9]), tensor([1])]
[tensor([15]), tensor([14]), tensor([13]), tensor([12]), tensor([11]), tensor([8]), tensor([7]), tensor([6]), tensor([5]), tensor([4]), tensor([3]), tensor([2])]这些批次的空间利用率高得多,浪费的空间更少。这就好比用你的数据进行俄罗斯方块游戏,将各个数据块紧密地拼接在一起。
[阶段 5] 多模态数据的背包问题
接下来是重头戏,将背包打包算法应用于我们的多模态数据集。
我们重新回到图像、提示词和响应数据,需要在尊重 token 限制和图像预算的前提下高效地进行打包。图像预算的分配旨在平衡每个样本中的图像数量。我们希望避免出现某个 GPU 需要处理的图像数量远多于其他 GPU 的情况。
新的 ConstantLengthDataset 类负责处理这些核心工作。以下是其工作原理,并与阶段 4 进行对比:
| 概念 | 阶段 4(玩具数据) | 阶段 5(多模态数据) | 函数 |
|---|---|---|---|
| Item | 整数(序列长度) | 完整样本(图像、提示词、响应) | VQADataset.__getitem__ |
| Weight | 整数本身 | Token 数量(len(input_ids)) | — |
| Knapsack | 总长 ≤ max_length 的整数批次 | 满足 seq_length 和图像数量限制的样本批次 | _balanced_greedy_knapsack |
| Packing Strategy | 贪心或 Binpack | 结合 token 和图像约束的贪心打包 | _balanced_greedy_knapsack |
| Producer-Consumer | 生产者填充队列 | 与玩具示例相同,但处理的是多模态样本 | _producer, __iter__ |
| Sample Filtering | 跳过大于 max_length 的整数 | 跳过 token 过多或图像过多的样本 | _producer |
| Sharding | 拆分整数范围 | 对数据集索引进行分片 | make_base_iterator() |
| Batching | 将整数分组 | 拼接并对齐 tokens/images | _pack_one_group |
| Output | 整数列表 | 包含 input_ids、labels、attention_mask、images 的字典 | yield from __iter__ |
ConstantLengthDataset 完成了所有工作:
结果如下:
看到了吗!灰色部分(padding)极少,且批次中充满了有效数据。这就像把行李箱塞得满满当当,却还能轻松拉上拉链,无需费力挤压。
乍看之下这张图可能不太直观,让我们将其与受约束的 padding 方案并排对比一下。
在这里你会注意到,背包算法中的样本分布更加均匀。同时,我们也不会遇到因过滤导致批次中样本数量减少的问题。
结论
最初只是对“为什么训练这么慢?”这一问题的简单调查,最终促使我们彻底重新思考如何处理多模态数据。
用于数据管道的平衡背包策略源自 NVIDIA 的论文 Eagle 2: Building Post-Training Data Strategies from Scratch for Frontier Vision-Language Models。
关键经验教训:
- 将所有序列填充至最长长度是一个不错的初步方案(但存在浪费)
- 将批处理视为一个装箱问题
- 考虑所有约束条件(文本长度、图像内存等)
- 先使用玩具数据进行测试,以验证你的方法
想要深入探索?请查看:
祝训练愉快(愿你的 GPU 始终保持忙碌状态)!





