Como Treinar Modelos Multimodais Pesados Sem um Zoológico de Scripts

Se você já tentou fazer fine-tuning de um modelo multimodal novo como Qwen2.5-VL ou executar um pré-treinamento de um gerador de vídeo baseado em difusão, provavelmente lembra dessa sensação de desespero. Em um repositório, o treinamento trava devido a conflitos de versão entre PyTorch e FlashAttention. Em outro, o autor escreveu um pipeline de dados customizado que carrega 500 GB de imagens diretamente na RAM. Em um terceiro, o FSDP congela completamente no segundo passo de otimização.

Cada nova arquitetura traz seu próprio script de treinamento, seus próprios hacks de economia de memória e suas próprias gambiarras para paralelismo. O time do laboratório EvolvingLMMs-Lab decidiu reunir toda essa experiência dispersa em um só lugar. Foi assim que surgiu o repositório lmms-engine.

É um motor modular para treinamento escalável de modelos multimodais. Ele cuida do trabalho pesado de treinamento distribuído, sequence packing e otimizações de kernel de baixo nível, deixando você apenas com um config e dados.

O Que Tem Dentro e Para Quem Serve

O framework foi desenvolvido principalmente para pesquisadores e engenheiros de ML que trabalham com redes multimodais pesadas. Enquanto LLMs textuais comuns podem ser facilmente ajustados com ferramentas como Axolotl ou LLaMA-Factory, imagens, áudio e vídeo são uma história diferente.

Entradas multimodais criam contextos massivos. Um único frame de alta resolução ou um par de segundos de vídeo facilmente se expandem para dezenas de milhares de tokens visuais. Nesse ponto, o Data Parallel padrão rapidamente atinge os limites de memória da GPU.

O motor resolve isso com uma combinação de técnicas modernas de paralelismo e otimizações no nível da GPU. A lista de modelos suportados é impressionante:

• Modelos Visão-Linguagem: Qwen2.5-VL, Qwen3-VL, Qwen3-VL MoE, LLaVA-OneVision
• MoE multimodal com suporte a áudio e vídeo: Qwen2.5-Omni, Qwen3-Omni MoE, Aero
• Arquiteturas generativas e de difusão: WanVideo (1.3B e 14B parâmetros), SiT (Scalable Interpolant Transformers), dLLM
• Sistemas universais de compreensão e geração de imagens: BAGEL

Quatro Soluções de Engenharia Por Trás dos Panos

Os criadores do projeto foram claramente inspirados pela ideia de minimalismo: o código é escrito de forma compacta, sem magia abstrata desnecessária, em PyTorch puro com integrações para bibliotecas de ponta.

1. FSDP2 e Ulysses Sequence Parallel

Para distribuir pesos, o motor depende da nova implementação do Fully Sharded Data Parallel v2 (FSDP2) baseada em DTensor. Diferente do FSDP antigo, a segunda versão se compõe muito mais cleanly com outros tipos de paralelismo.

Quando 10.000+ tokens visuais entram no contexto, a memória da GPU se esgota instantaneamente. É aí que entra o Ulysses Sequence Parallel (USP). Ele divide a sequência de tokens entre várias GPUs dentro de um único nó. No config, isso é definido com uma única linha:

trainer_args:
  sp_ulysses_degree: 2

2. Sequence Packing Sem Padding Desnecessário

Uma dor de cabeça clássica no treinamento multimodal é o tamanho variável de imagens e textos em um único batch. Se você preencher amostras curtas com tokens de padding, a GPU gasta até metade do tempo em cálculos zeros inúteis.

Os autores implementaram first-fit bin packing em combinação com FlashAttention use_rmpad. Os dados são empacotados em sequências longas densas sem tempo ocioso. De acordo com os benchmarks dos autores, no fine-tuning do Qwen2.5-VL, a métrica de eficiência computacional (MFU) salta de 20-25% para impressionantes 35-40%.

dataset_config:
  packing: true
  packing_strategy: first_fit
  packing_length: 32000

trainer_args:
  use_rmpad: true
  use_liger_kernel: true

3. Otimizador Muon e Kernels Triton do Liger

Em vez do familiar AdamW, o projeto oferece Muon. Este otimizador aplica ortogonalização de Newton-Schulz via kernels Triton em matrizes de peso 2D. Ele converge mais rápido que o AdamW e requer menos memória.

Ao mesmo tempo, o motor pode trocar camadas de modelo padrão em tempo real com kernels fundidos da biblioteca Liger Kernel do LinkedIn. CrossEntropy, RMSNorm, RoPE e SwiGLU são fundidos em operações únicas, cortando cerca de 30% do consumo de VRAM de pico sem perda de acurácia.

4. Carregamento Streaming de Datasets de Terabytes

Carregar arrays massivos de vídeos e imagens na memória antes de iniciar uma época é impossível. O pipeline de dados no lmms-engine é construído em cima de IterableDataset. Os dados são lidos em stream de formatos Arrow, JSONL ou Parquet, então o treinamento começa imediatamente sem esperar pela indexação de arquivos de terabytes.

Como Funcionam Execução e Extensão

A instalação do projeto é feita corretamente através do gerenciador de pacotes uv, embora os autores também forneçam uma imagem Docker pronta com CUDA, FlashAttention e dependências pré-instaladas.

git clone https://github.com/EvolvingLMMs-Lab/lmms-engine.git
cd lmms-engine
uv pip install -e ".[all]"
uv pip install flash-attn --no-build-isolation
uv pip install liger-kernel

O treinamento começa via torchrun padrão:

torchrun --nproc_per_node=8 --nnodes=1 --node_rank=0 \
  --master_addr=127.0.0.1 --master_port=12355 \
  -m lmms_engine.launch.cli config_yaml=examples/qwen3_vl/example_config.yaml

Se você precisar adicionar seu próprio formato de dados específico ou processador de features customizado, não precisará reescrever os internos do trainer. O código usa um factory pattern com registro via decorators:

from lmms_engine.datasets import register_dataset, BaseDataset

@register_dataset("my_custom_dataset")
class MyCustomDataset(BaseDataset):
    def __init__(self, config):
        super().__init__(config)

    def __getitem__(self, idx):
        # Ваша логика чтения картинки или видео
        return item

Onde o Projeto Mais Se Destaca

O motor foi desenvolvido para cenários pesados específicos:

1. Fine-tuning de modelos visão-linguagem (Qwen2.5-VL, Qwen3-VL) em documentos longos, digitalizações de livros e capturas de interface.
2. Treinamento de arquiteturas sparse Mixture-of-Experts com distribuição de experts entre GPUs (Expert Parallelism).
3. Experimentos com difusão para geração de vídeo baseada nos modelos WanVideo ou SiT.
4. Pré-treinamento de modelos leves com atenção recorrente e linear (FLA / DGN).

Vale a Pena Experimentar

Se sua tarefa é ajustar rapidamente LoRA em um Llama textual, o lmms-engine pode parecer overkill. Mas se você atingiu um teto de memória ao treinar redes multimodais, está cansado de manualmente integrar FSDP2 com sequências longas de vídeo, ou quer extrair o máximo de FLOPS dos seus clusters existentes, este motor vai economizar semanas de codificação.

A forma mais fácil de começar é com os scripts prontos na pasta examples/: eles contêm configurações testadas em batalha para a maioria das arquiteturas modernas.