Come Addestrare Modelli Multimodali Pesanti Senza un Zoo di Script

Se hai mai provato a fare fine-tuning di un modello multimodale fresco come Qwen2.5-VL o eseguire un pretrain di un generatore video basato su diffusion, probabilmente ricordi quella sensazione di disperazione. In un repository, il training va in crash a causa di conflitti di versione tra PyTorch e FlashAttention. In un altro, l'autore ha scritto una pipeline dati personalizzata che carica 500 GB di immagini direttamente in RAM. In un terzo, FSDP si blocca solido al secondo step di ottimizzazione.

Ogni nuova architettura porta con sé il proprio script di training, i propri hack per risparmiare memoria e i propri workaround per il parallelismo. Il team del laboratorio EvolvingLMMs-Lab ha deciso di raccogliere tutta questa esperienza sparsa in un unico posto. È così che è nato il repository lmms-engine.

È un motore modulare per il training scalabile di modelli multimodali. Gestisce il lavoro sporco del training distribuito, del sequence packing e delle ottimizzazioni dei kernel di basso livello, lasciando a te solo la configurazione e i dati.

Cosa C'è Dentro e Per Chi È

Il framework è stato sviluppato principalmente per ricercatori e ingegneri ML che lavorano con reti multimodali pesanti. Mentre i normali LLM testuali possono essere comodamente sottoposti a fine-tuning con strumenti come Axolotl o LLaMA-Factory, immagini, audio e video sono tutta un'altra storia.

Gli input multimodali creano contesti di lunghezza massiccia. Un singolo frame ad alta risoluzione o un paio di secondi di video si espandono facilmente in decine di migliaia di token visivi. A quel punto, il classico Data Parallel standard raggiunge rapidamente i limiti di memoria GPU.

Il motore risolve questo con una combinazione di tecniche moderne di parallelismo e ottimizzazioni a livello GPU. La lista dei modelli supportati è impressionante:

• Modelli Vision-Language: Qwen2.5-VL, Qwen3-VL, Qwen3-VL MoE, LLaVA-OneVision
• MoE multimodale con supporto audio e video: Qwen2.5-Omni, Qwen3-Omni MoE, Aero
• Architetture generative e diffusion: WanVideo (1.3B e 14B parametri), SiT (Scalable Interpolant Transformers), dLLM
• Sistemi universali di comprensione e generazione di immagini: BAGEL

Quattro Soluzioni Ingegneristiche Sotto il Cofano

I creatori del progetto sono stati chiaramente ispirati dall'idea del minimalismo: il codice è scritto in modo compatto, senza magia astratta non necessaria, in puro PyTorch con integrazioni per librerie all'avanguardia.

1. FSDP2 e Ulysses Sequence Parallel

Per distribuire i pesi, il motore si affida alla nuova implementazione di Fully Sharded Data Parallel v2 (FSDP2) basata su DTensor. A differenza del vecchio FSDP, la seconda versione si compone in modo molto più pulito con altri tipi di parallelismo.

Quando 10.000+ token visivi volano nel contesto, la memoria GPU si esaurisce istantaneamente. È qui che entra in gioco Ulysses Sequence Parallel (USP). Suddivide la sequenza di token su diverse GPU all'interno di un singolo nodo. Nella configurazione, questo viene impostato con una singola riga:

trainer_args:
  sp_ulysses_degree: 2

2. Sequence Packing Senza Padding Inutile

Un classico mal di testa nel training multimodale sono le dimensioni variabili di immagini e testi in un singolo batch. Se fai padding dei campioni corti con token di riempimento, la GPU trascorre fino alla metà del tempo su calcoli zero inutili.

Gli autori hanno implementato il first-fit bin packing in combinazione con FlashAttention use_rmpad. I dati vengono compattati in sequenze lunghe e dense senza tempi morti. Secondo i benchmark degli autori, sul fine-tuning di Qwen2.5-VL, la metrica di efficienza computazionale (MFU) sale dal 20-25% a un impressionante 35-40%.

dataset_config:
  packing: true
  packing_strategy: first_fit
  packing_length: 32000

trainer_args:
  use_rmpad: true
  use_liger_kernel: true

3. Ottimizzatore Muon e Kernel Triton di Liger

invece del familiare AdamW, il progetto offre Muon. Questo ottimizzatore applica l'ortonormalizzazione Newton-Schulz tramite kernel Triton alle matrici di pesi 2D. Converge più velocemente di AdamW e richiede meno memoria.

Allo stesso tempo, il motore può scambiare al volo i layer standard del modello con kernel fusi dalla libreria Liger Kernel di LinkedIn. CrossEntropy, RMSNorm, RoPE e SwiGLU vengono fusi in singole operazioni, riducendo circa il 30% del consumo di VRAM di picco senza perdita di accuratezza.

4. Caricamento Streaming di Dataset da Terabyte

Caricare array massicci di video e immagini in memoria prima dell'inizio di un'epoca è impossibile. La pipeline dati in lmms-engine è costruita sopra IterableDataset. I dati vengono letti in streaming da formati Arrow, JSONL o Parquet, quindi il training inizia immediatamente senza aspettare che i file da terabyte vengano indicizzati.

Come Funzionano Avvio ed Estensione

L'installazione del progetto viene fatta correttamente tramite il package manager uv, anche se gli autori forniscono anche un'immagine Docker pronta con CUDA, FlashAttention e dipendenze preinstallate.

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

Il training parte tramite standard torchrun:

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 hai bisogno di aggiungere il tuo formato dati specifico o un processore di feature personalizzato, non dovrai riscrivere gli interni del trainer. Il codice usa un pattern factory con registrazione tramite decorator:

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

Dove il Progetto Brilla Meglio

Il motore è stato sviluppato per scenari pesanti specifici:

1. Fine-tuning di modelli vision-language (Qwen2.5-VL, Qwen3-VL) su documenti lunghi, scansioni di libri e screenshot di interfacce.
2. Training di architetture sparse Mixture-of-Experts con distribuzione degli esperti sulle GPU (Expert Parallelism).
3. Esperimenti con diffusion per la generazione video basati su modelli WanVideo o SiT.
4. Pretraining di modelli leggeri con attenzione ricorrente e lineare (FLA / DGN).

Vale la Pena Provare

Se il tuo compito è fare rapidamente un tweak LoRA su un Llama testuale, lmms-engine potrebbe sembrare eccessivo. Ma se hai raggiunto un soffitto di memoria quando alleni reti multimodali, sei stanco di legare manualmente FSDP2 con sequenze video lunghe, o vuoi spremere il massimo FLOPS dai tuoi cluster esistenti, questo motore ti farà risparmiare settimane di codifica.

Il modo più semplice per iniziare è con gli script pronti nella cartella examples/: contengono configurazioni battle-tested per la maggior parte delle architetture moderne.