Hugging Face 开源 MMDP:多模态数据管道优化方案,解决 GPU 闲置与填充浪费

原标题:Efficient MultiModal Data Pipeline
68AI 研判分

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 项目中进行了一些排查工作后,我们 发现真正的罪魁祸首既不是我们的模型也不是硬件,而是极其浪费的数据流水线。

以下是我们发现的问题:

  1. GPU 闲置:我们的模型实际上只是在干等着数据到来
  2. 填充地狱:每个批次都塞满了毫无用处的填充 token,对训练没有任何贡献

在这篇文章中,我们将通过 五个阶段 构建一个高效的流水线。在每个阶段,我们会在前一步的基础上增加或移除某些内容,并评论哪些地方做对了,哪些地方没有。

目录:

[阶段 0] 准备工作

为了让数据准备任务更易于跟随,我们创建了一个独立的仓库,专门聚焦于数据流水线本身。我们希望这比阅读集成到 nanoVLM 仓库中的代码更容易理解。此外,这也可能有助于引导其他数据流水线的开发!

代码仓库:https://github.com/ariG23498/mmdp

要跟随本文操作,你只需克隆该仓库。仓库中包含了最终的数据准备任务,但其设计初衷是逐步展示每个环节。

BASH
$ git clone https://github.com/ariG23498/mmdp.git

[阶段 1] 数据集可视化

在进行任何优化之前,我们需要先了解手头的数据。我们的多模态数据集包含图像、文本提示(prompts)和响应。

BASH
$ uv run 01_check_dataset.py

Dataset Sample

熟悉训练数据对于成功至关重要。上述脚本每次运行都会显示一个随机样本;你可能希望将该代码片段复制到 notebook 中并多次运行,以更好地感知数据分布。

[阶段 2] 朴素填充(Naive Padding)

我们首次尝试训练时采用了显而易见(且非常常见)的方法:

  • 对所有数据进行分词(Tokenize)
  • 找出每个批次中最长的序列
  • 将其他所有序列填充至相同长度
BASH
$ uv run 02_naive_pad_dataloader.py

结果令人痛苦。请看这张可视化图:

Naive Padding Waste

看到那些灰色区域了吗?那就是填充部分。这意味着 GPU 正在处理毫无意义的内容,而你却在为此支付算力成本。我们大约浪费了 60% 的批次容量在空 token 上。

[阶段 3] 受限填充(Constrained Padding)

我们的下一步很简单:设定一个全局最大长度并严格遵守。如果某个样本过长,就直接丢弃它。

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 之间分片数据等技巧:

PYTHON
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 队列 实现了 生产者-消费者 模式:

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)

生产者线程负责打包批次并将其放入队列,而主线程则按需从中取出。这种重叠机制使流水线能够保持流畅运行。

贪心打包

首先,我们尝试一种简单的 贪心打包 策略:

PYTHON
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

该策略按顺序遍历数据,将项目添加到包中直到装满,然后开始新的包。这种方法速度快但并不完美。以下是生成的批次示例:

BASH
=== 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])]

Greedy Knapsack

请注意后面的批次变得多么稀疏?我们留下了空隙。

装箱算法以实现更紧凑的填充

让我们尝试一种更智能的方法:装箱问题(具体来说是“首次适应递减”算法):

PYTHON
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])

这会将序列按长度排序(最长的优先),并尝试将每个序列放入第一个有足够空间的“包”中。如果没有合适的包,则开始一个新的包。结果如下:

BASH
=== 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])]

Tight

这些批次的空间利用率高得多,浪费的空间更少。这就好比用你的数据进行俄罗斯方块游戏,将各个数据块紧密地拼接在一起。

[阶段 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 完成了所有工作:

  • 读取样本(图像和文本)。
  • 过滤掉过长或图像过多的样本。
  • 使用贪心背包策略将样本打包成批次,平衡 token 数量和图像数量。
  • 将最终批次填充至固定长度,但 padding 大幅减少。

结果如下:

Knapsack Padding

看到了吗!灰色部分(padding)极少,且批次中充满了有效数据。这就像把行李箱塞得满满当当,却还能轻松拉上拉链,无需费力挤压。

乍看之下这张图可能不太直观,让我们将其与受约束的 padding 方案并排对比一下。

KnapsackConstrained
Knapsack PaddingConstrained Padding

在这里你会注意到,背包算法中的样本分布更加均匀。同时,我们也不会遇到因过滤导致批次中样本数量减少的问题。

结论

最初只是对“为什么训练这么慢?”这一问题的简单调查,最终促使我们彻底重新思考如何处理多模态数据。

用于数据管道的平衡背包策略源自 NVIDIA 的论文 Eagle 2: Building Post-Training Data Strategies from Scratch for Frontier Vision-Language Models。

关键经验教训:

  • 将所有序列填充至最长长度是一个不错的初步方案(但存在浪费)
  • 将批处理视为一个装箱问题
  • 考虑所有约束条件(文本长度、图像内存等)
  • 先使用玩具数据进行测试,以验证你的方法

想要深入探索?请查看:

祝训练愉快(愿你的 GPU 始终保持忙碌状态)!