I modelli di diffusione hanno alimentato alcune delle più entusiasmanti release open-source degli ultimi due anni — pensa a FLUX.1-dev per text-to-image, o Wan 2.1 e HunyuanVideo per text-to-video. La libreria 🤗 Diffusers è diventata la casa di riferimento per questi modelli, offrendo a ricercatori e sviluppatori un'interfaccia unica e coerente per inferenza, adattamento e composizione di pipeline.

Anche l'addestramento e il fine-tuning di questi modelli sono in aumento, e ciò richiede strumenti in grado di gestire sharding efficiente in memoria, caching latente, bucketing multi-risoluzione e configurazioni che scalano senza problemi da una GPU a centinaia.

Ecco la libreria open-source NVIDIA NeMo Automodel. Oggi mettiamo in luce la collaborazione tra NVIDIA e Hugging Face che porta l'addestramento distribuito di diffusione di livello produttivo a qualsiasi modello in formato Diffusers sull'Hugging Face Hub — senza conversione di checkpoint, senza riscrittura del modello per nuovi modelli. L'integrazione è documentata nella guida all'addestramento di Diffusers ed è completamente open-source sotto Apache 2.0.

Cos'è NeMo Automodel?

NeMo Automodel è una libreria di addestramento open-source nativa PyTorch DTensor, parte del framework NVIDIA NeMo. È costruita attorno a due principi di progettazione importanti per l'ecosistema Diffusers:

  • Nativo Hugging Face. Punta pretrained_model_name_or_path a qualsiasi ID di modello Diffusers sull'Hub e inizia l'addestramento. NeMo Automodel usa le classi di modello Diffusers (es. WanTransformer3DModel) per il caricamento e le pipeline Diffusers (WanPipeline) per la generazione. I checkpoint tornano pulitamente nell'ecosistema Diffusers.

  • Un programma, qualsiasi scala. Le ricette e gli script di addestramento possono essere facilmente modificati per adattarsi a qualsiasi scala. Il parallelismo è una scelta di configurazione, non una riscrittura del codice — passa tra FSDP2, tensor parallel, expert parallel, context parallel e pipeline parallel dichiarando configurazioni, non riscrivendo modelli.

AutoModel attualmente supporta solo modelli flow-matching. Sotto il cofano, usa il flow matching come obiettivo di addestramento, con addestramento nello spazio latente (tramite output VAE pre-codificati) e caricamento dati con bucketing multi-risoluzione per accelerare il throughput.

Modelli di diffusione supportati

L'integrazione NeMo Automodel include ricette di fine-tuning pronte all'uso per i modelli di diffusione open-source elencati di seguito. La lista riflette le ricette attualmente in examples/diffusion/finetune.

ModelloID Hugging FaceCompitoParametriRicetta LoRAWan 2.1 T2V 1.3B / 14BWan-AI/Wan2.1-T2V-1.3B-Diffusers / Wan-AI/Wan2.1-T2V-14B-DiffusersText-to-Video1.3B (sta su una singola A100 da 40GB) / 14BSìWan 2.2 T2V A14BWan-AI/Wan2.2-T2V-A14B-DiffusersText-to-Video27B totale (MoE), 14B attivi per passoNoFLUX.1-devblack-forest-labs/FLUX.1-devText-to-Image12BSìFLUX.2-devblack-forest-labs/FLUX.2-devText-to-Image32BSìHunyuanVideo 1.5hunyuanvideo-community/HunyuanVideo-1.5-Diffusers-720p_t2vText-to-Video13BSìQwen-ImageQwen/Qwen-ImageText-to-Image20B (MMDiT)Sì

Cosa sblocca questa collaborazione

Per gli utenti Diffusers, i vantaggi pratici si suddividono in alcune capacità concrete.

Nessuna conversione di checkpoint. I pesi pre-addestrati dall'Hub funzionano subito. Non esiste un "formato di addestramento" separato a cui convertire e poi riconvertire. Il tuo checkpoint fine-tuned si carica direttamente in un DiffusionPipeline per l'inferenza, o torna all'Hub per la condivisione. Gli strumenti a valle — quantizzazione, compilazione, adattatori LoRA, sampler personalizzati — continuano a funzionare.

Percorso rapido per il supporto di nuovi modelli. Quando un nuovo modello di diffusione arriva in Diffusers, abilitarlo in NeMo Automodel richiede un'aggiunta di codice piccola e contenuta — un gestore di pre-elaborazione dati e un adattatore del modello — piuttosto che uno script di addestramento personalizzato completo. Il resto dello stack di ricette (FSDP2, caricamento dati con bucketing, checkpointing, generazione) rimane invariato, e lo stesso flusso di lavoro basato su YAML si applica.

Fine-tuning completo e con parametri efficienti. Sono supportati sia il fine-tuning completo che il PEFT stile LoRA, così puoi scegliere tra massima qualità (full FT su un grande cluster) o massima efficienza (LoRA su un singolo nodo). La stessa struttura di ricetta gestisce entrambi.

Addestramento scalabile che va oltre ciò che offrono gli script integrati. NeMo Automodel aggiunge schemi di sharding come FSDP2, tensor, context e pipeline parallelism, orchestrazione multi-nodo (SLURM oggi, Kubernetes in arrivo) e bucketing multi-risoluzione. Queste capacità rendono possibile l'addestramento di modelli più grandi come FLUX.1-dev (12B) e HunyuanVideo (13B).

Uno sguardo al flusso di lavoro di fine-tuning

In questa sezione, esaminiamo il flusso di lavoro tipico per il fine-tuning di uno qualsiasi dei modelli supportati. Il modo consigliato per installare Automodel è il container Docker NeMo Automodel (nvcr.io/nvidia/nemo-automodel:26.06), che include PyTorch, TransformerEngine e altre dipendenze compilate con CUDA pre-costruite. In alternativa, installa con pip3 install nemo-automodel o dal sorgente (pip3 install git+https://github.com/NVIDIA-NeMo/Automodel.git); consulta la guida all'installazione per tutte le opzioni.

Questa guida illustra un fine-tuning full-transformer di FLUX.1-dev sul dataset di tarocchi Rider–Waite a 78 carte, quindi la generazione dal checkpoint risultante. Riutilizza i file di configurazione YAML già presenti e applica le impostazioni specifiche dell'esecuzione come override da riga di comando, quindi non sono necessari nuovi file di configurazione.

1. Pre-codificare il dataset

La ricetta di diffusione consuma latenti VAE e embedding di testo memorizzati nella cache invece di codificare le immagini sorgente durante ogni passo di addestramento. Trasmetti le 78 immagini Rider–Waite direttamente da Hugging Face e distribuisci la pre-elaborazione su tutte le GPU visibili:

uv run --locked --no-default-groups \
  --extra diffusion \
  --extra diffusion-media \
python -m tools.diffusion.preprocessing_multiprocess image \
  --dataset_name multimodalart/1920-raider-waite-tarot-public-domain \
  --dataset_media_column image \
  --dataset_caption_column caption \
  --dataset_streaming \
  --max_images 78 \
  --output_dir /cache/flux_tarot \
  --processor flux \
  --model_name black-forest-labs/FLUX.1-dev \
  --max_pixels 245760

Le didascalie contengono già il token trigger trtcrd. Con questo budget di pixel e il rapporto d'aspetto verticale del dataset, la pre-elaborazione assegna i campioni al bucket 384×640 utilizzato nell'esecuzione dimostrativa.

Per l'addestramento su immagini, la pre-elaborazione produce file cache .pt e metadati shardati:

/cache/flux_tarot/
├── 384x640/
│   ├── <hash1>.pt
│   └── ...
├── metadata_shard_0000.json
├── metadata.json
└── _hf_dataset/
    └── images/

2. Avviare l'addestramento con il YAML FLUX esistente

Usa direttamente examples/diffusion/finetune/flux_t2i_flow.yaml. Il YAML seleziona già FLUX.1-dev, fine-tuning completo del trasformatore, l'adattatore flow-matching FLUX, una batch size effettiva di 32 e FSDP2 a otto vie.

Fornisci i percorsi e le impostazioni specifici dei tarocchi come override da riga di comando:

uv run --locked --no-default-groups --extra diffusion \
  torchrun --nproc-per-node=8 \
  examples/diffusion/finetune/finetune.py \
  -c examples/diffusion/finetune/flux_t2i_flow.yaml \
  --model.transformer_engine_fp8 false \
  --data.dataloader.cache_dir /cache/flux_tarot \
  --data.dataloader.base_resolution '[384,640]' \
  --lr_scheduler.lr_decay_style constant \
  --lr_scheduler.lr_warmup_steps 20 \
  --step_scheduler.max_steps 200 \
  --step_scheduler.ckpt_every_steps 50 \
  --checkpoint.checkpoint_dir /tmp/flux_tarot/checkpoints/full \
  --checkpoint.save_consolidated true \
  --seed 2026

L'esecuzione produce checkpoint ai passi 50, 100, 150 e 200. Il checkpoint finale è etichettato epoch_66_step_199; l'etichetta è a base zero anche se rappresenta il 200° passo dell'ottimizzatore completato.

3. Generare dal checkpoint fine-tuned

Usa il YAML di generazione FLUX esistente e punta model.checkpoint al checkpoint di addestramento completo:

uv run --locked --no-default-groups --extra diffusion \
  python examples/diffusion/generate/generate.py \
  -c examples/diffusion/generate/configs/generate_flux.yaml \
  --model.checkpoint /tmp/flux_tarot/checkpoints/full/epoch_66_step_199 \
  --inference.height 640 \
  --inference.width 384 \
  --inference.prompts '["a trtcrd of an astronaut tending a rose garden on Mars, \"the gardener\""]' \
  --output.output_dir /tmp/flux_tarot/generations/full/step_200 \
  --seed 2026

Includi trtcrd per invocare lo stile tarocco appreso. Per un confronto di controllo, mantieni il seed e la scena fissi ma ometti il trigger:

uv run --locked --no-default-groups --extra diffusion \
  python examples/diffusion/generate/generate.py \
  -c examples/diffusion/generate/configs/generate_flux.yaml \
  --model.checkpoint /tmp/flux_tarot/checkpoints/full/epoch_66_step_199 \
  --inference.height 640 \
  --inference.width 384 \
  --inference.prompts '["an astronaut tending a rose garden on Mars, \"the gardener\""]' \
  --output.output_dir /tmp/flux_tarot/generations/control \
  --seed 2026

Risultati

Al passo 200, i prompt con astronauta triggerato mantengono il contenuto richiesto mentre acquisiscono una tavolozza vintage crema, rosso e nero, contorni a inchiostro spessi, campi di colore piatti, toni di carta invecchiata e composizione allegorica da carte. L'astronauta non triggerato rimane fotografico, dimostrando che l'effetto appreso è sostanzialmente associato a trtcrd piuttosto che sostituire il modello base globalmente.

Prompt (seed)BaselineFine-tuned (passo 200)Astronauta che cura un roseto su Marte (seed 2026)

4. Performance

Tutte le misurazioni sono state raccolte su un nodo con 8 GPU NVIDIA H100 80GB. I risultati sono medie ± deviazione standard campionaria su tre finestre di 10 passi in stato stazionario.

Text-to-image — 512×512

ModelloAddestramentoParallelismoGBS / LBSTempo per passoImmagini/sImmagini/s/GPUPeak allocato/GPUFLUX.1-devCompletoFSDP232 / 40.902 ± 0.039 s35.51 ± 1.554.44 ± 0.1963.88 GiBFLUX.1-devLoRA r64DDP48 / 60.894 ± 0.008 s53.73 ± 0.486.72 ± 0.0667.43 GiBQwen-ImageCompletoFSDP240 / 50.974 ± 0.075 s41.21 ± 3.065.15 ± 0.3853.55 GiBQwen-ImageLoRA r64DDP24 / 30.515 ± 0.006 s46.63 ± 0.545.83 ± 0.0766.33 GiB

Text-to-video — 512×512×49 fotogrammi

Ogni campione è un clip video di 49 fotogrammi.

ModelloAddestramentoGBS / LBSActivation checkpointingTempo per passoClip/sClip/s/GPUPeak allocato/GPUWan 2.1 1.3BCompleto8 / 1Spento0.942 ± 0.038 s8.50 ± 0.351.06 ± 0.046.09 GiBWan 2.1 14BCompleto8 / 1Acceso3.798 ± 0.017 s2.107 ± 0.0060.263 ± 0.00633.35 GiBWan 2.1 14BLoRA r6416 / 2Acceso7.585 ± 0.014 s2.110 ± 0.0000.263 ± 0.00024.07 GiBWan 2.2 A14B, alto rumoreCompleto8 / 1Acceso4.628 ± 0.031 s1.730 ± 0.0100.217 ± 0.00623.57 GiBHunyuanVideo 1.5Completo8 / 1Acceso5.926 ± 0.046 s1.350 ± 0.0100.170 ± 0.00015.90 GiBHunyuanVideo 1.5LoRA r648 / 1Acceso5.575 ± 0.006 s1.433 ± 0.0060.180 ± 0.00010.58 GiB

Dettagli di misurazione

  • Hardware: 8× H100 80GB HBM3, completamente connessi NVLink.

  • Dataset immagini: lambda/naruto-blip-captions, 256 campioni in cache.

  • Dataset video: svjack/Lelouch_Vi_Britannia_FramePack_First_Last_Frame_Video_Captioned, 112 campioni in cache.

  • Batch completi sono stati imposti con drop_last=true.

  • Le scritture di checkpoint sono state disabilitate.

  • Il tempo per passo include caricamento dati, forward, backward, gradient clipping, ottimizzatore e scheduler.

  • La memoria è il picco di utilizzo dell'allocatore CUDA di PyTorch, non la memoria totale del dispositivo NVML.

Altri esempi di fine-tuning/LoRA

I risultati del fine-tuning e LoRA mostrano la potenza di NeMo Automodel per la specializzazione di dominio. Ad esempio, il fine-tuning del modello Wan 2.1 su un dataset video Ghibli ha adattato con successo lo stile di output, dimostrato da un notevole cambiamento nell'aspetto di un fiore rispetto alla baseline.

Baseline:

Fine-tuned su video Ghibli:

Abbiamo anche osservato l'impatto distintivo dell'uso di LoRA, dove l'applicazione dell'adattatore a Wan 2.1 ha fatto sì che il video adottasse uno stile Ghibli caratteristico, particolarmente visibile nell'evidenziazione degli occhi dei personaggi.

Senza LoRA:

Con LoRA:

Questi esempi, inclusi quelli per FLUX.2, confermano che gli utenti possono ottenere sia la massima qualità tramite fine-tuning completo sia la massima efficienza tramite PEFT stile LoRA, personalizzando l'output per domini stilistici specifici.

Provatelo oggi

Scopri di più sull'integrazione e trova altri esempi di fine-tuning nella documentazione di NeMo Automodel

Prossimamente: API di ricette Pythonic

YAML è un'ottima scelta per configurazioni riproducibili, specialmente per team che vogliono file da poter versionare, revisionare e riutilizzare, ma molti team hanno anche bisogno di un'interfaccia programmatica.

In una prossima release di NeMo Automodel, prevediamo di esporre le ricette di diffusione anche tramite un'API Pythonic completamente tipizzata. Gli utenti potranno comporre gli stessi componenti di modello, dati, ottimizzatore, PEFT/LoRA, parallelismo, checkpointing e generazione direttamente da Python.

Il percorso Pythonic ha lo scopo di rendere le ricette più facili da usare da codice di addestramento esistente, notebook e flussi di lavoro sperimentali, e di offrire un'interfaccia Pythonic di prima classe insieme al percorso rapido YAML.