Diffusiemodellen hebben de afgelopen twee jaar enkele van de meest opwindende open-source releases mogelijk gemaakt — denk aan FLUX.1-dev voor tekst-naar-beeld, of Wan 2.1 en HunyuanVideo voor tekst-naar-video. De 🤗 Diffusers-bibliotheek is de thuisbasis geworden voor deze modellen, waardoor onderzoekers en bouwers één enkele, consistente interface hebben voor inferentie, aanpassing en pipeline-compositie.

Training en fine-tuning van deze modellen neemt ook toe, en dat vraagt om tools die geheugenefficiënte sharding, latente caching, multiresolutie bucketing en configuraties ondersteunen die soepel schalen van één GPU tot honderden.

Maak kennis met de NVIDIA NeMo Automodel open-source bibliotheek. Vandaag belichten we de samenwerking tussen NVIDIA en Hugging Face die productieklare, gedistribueerde diffusietraining mogelijk maakt voor elk Diffusers-formaat model op de Hugging Face Hub — zonder checkpoint-conversie, zonder modelherschrijvingen voor nieuwe modellen. De integratie is gedocumenteerd in de Diffusers-trainingsgids en is volledig open source onder Apache 2.0.

Wat is NeMo Automodel?

NeMo Automodel is een open-source PyTorch DTensor-native trainingsbibliotheek, onderdeel van het NVIDIA NeMo-framework. Het is gebouwd rond twee ontwerpprincipes die belangrijk zijn voor het Diffusers-ecosysteem:

  • Hugging Face native. Wijs pretrained_model_name_or_path naar een Diffusers-model-ID op de Hub en begin met trainen. NeMo Automodel gebruikt Diffusers-modelklassen (bijv. WanTransformer3DModel) voor het laden en Diffusers-pipelines (WanPipeline) voor generatie. Checkpoints kunnen naadloos worden teruggeplaatst in het Diffusers-ecosysteem.

  • Eén programma, elke schaal. De recepten en trainingsscripts kunnen eenvoudig worden aangepast voor training op elke schaal. Parallelisme is een configuratiekeuze, geen codeherschrijving — schakel tussen FSDP2, tensor parallel, expert parallel, context parallel en pipeline parallel door configuraties te declareren, niet door modellen te herschrijven.

AutoModel ondersteunt momenteel alleen flow-matching modellen. Onder de motorkap gebruikt het flow matching als trainingsdoel, met latent-space training (via voorgecodeerde VAE-uitvoer) en multiresolutie bucketed dataloading om de doorvoer te versnellen.

Ondersteunde diffusiemodellen

De NeMo Automodel-integratie wordt geleverd met kant-en-klare fine-tuning recepten voor de onderstaande open diffusiemodellen. De lijst weerspiegelt de recepten die momenteel in examples/diffusion/finetune staan.

ModelHugging Face IDTaakParametersLoRA-receptWan 2.1 T2V 1.3B / 14BWan-AI/Wan2.1-T2V-1.3B-Diffusers / Wan-AI/Wan2.1-T2V-14B-DiffusersTekst-naar-video1.3B (past op een enkele 40GB A100) / 14BJaWan 2.2 T2V A14BWan-AI/Wan2.2-T2V-A14B-DiffusersTekst-naar-video27B totaal (MoE), 14B actief per stapNeeFLUX.1-devblack-forest-labs/FLUX.1-devTekst-naar-beeld12BJaFLUX.2-devblack-forest-labs/FLUX.2-devTekst-naar-beeld32BJaHunyuanVideo 1.5hunyuanvideo-community/HunyuanVideo-1.5-Diffusers-720p_t2vTekst-naar-video13BJaQwen-ImageQwen/Qwen-ImageTekst-naar-beeld20B (MMDiT)Ja

Wat deze samenwerking mogelijk maakt

Voor Diffusers-gebruikers vallen de praktische voordelen uiteen in een paar concrete mogelijkheden.

Geen checkpoint-conversie. Voorgetrainde gewichten van de Hub werken direct uit de doos. Er is geen aparte "trainingsformaat" om naar te converteren en vervolgens terug te converteren. Je fijngetunde checkpoint laadt direct in een DiffusionPipeline voor inferentie, of terug naar de Hub om te delen. Downstream-tools — kwantisatie, compilatie, LoRA-adapters, aangepaste samplers — blijven allemaal werken.

Snelle weg naar ondersteuning van nieuwe modellen. Wanneer een nieuw diffusiemodel in Diffusers verschijnt, kost het inschakelen ervan in NeMo Automodel een kleine, beperkte code-toevoeging — een data-preprocessing handler en een modeladapter — in plaats van een volledig aangepast trainingsscript. De rest van de receptenstack (FSDP2, bucketed dataloading, checkpointing, generatie) blijft ongewijzigd en dezelfde YAML-gestuurde workflow is van toepassing.

Volledige en parameter-efficiënte fine-tuning. Zowel volledige fine-tuning als LoRA-stijl PEFT worden ondersteund, zodat je kunt kiezen tussen maximale kwaliteit (volledige FT op een groot cluster) of maximale efficiëntie (LoRA op een enkele node). Dezelfde receptstructuur behandelt beide.

Schaalbare training die verder gaat dan wat ingebouwde scripts bieden. NeMo Automodel voegt sharding-schema's toe zoals FSDP2, tensor-, context- en pipeline-parallelismen, multi-node orkestratie (momenteel SLURM, Kubernetes komt eraan) en multiresolutie bucketing. Deze mogelijkheden maken training van grotere modellen zoals FLUX.1-dev (12B) en HunyuanVideo (13B) mogelijk.

Een blik op de fine-tuning workflow

In deze sectie doorlopen we de typische workflow voor het fine-tunen van een van de ondersteunde modellen. De aanbevolen manier om Automodel te installeren is de NeMo Automodel Docker-container (nvcr.io/nvidia/nemo-automodel:26.06), die wordt geleverd met vooraf gebouwde PyTorch, TransformerEngine en andere CUDA-gecompileerde afhankelijkheden. Als alternatief kun je installeren met pip3 install nemo-automodel of vanuit de bron (pip3 install git+https://github.com/NVIDIA-NeMo/Automodel.git); zie de installatiehandleiding voor alle opties.

Deze gids doorloopt een full-transformer fine-tune van FLUX.1-dev op de 78-kaart Rider-Waite tarot-dataset, gevolgd door generatie vanuit het resulterende checkpoint. Het hergebruikt de ingecheckte YAML-configuraties en past runspecifieke instellingen toe als commandoregel-overrides, zodat er geen nieuwe configuratiebestanden nodig zijn.

1. Voorcodeer de dataset

Het diffusie-recept verbruikt gecachte VAE-latents en tekst-embeddings in plaats van bronafbeeldingen tijdens elke trainingsstap te coderen. Stream de 78 Rider-Waite-afbeeldingen rechtstreeks van Hugging Face en verdeel de preprocessing over alle zichtbare GPU's:

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

De bijschriften bevatten al het trtcrd triggertoken. Met dit pixelbudget en de portretbeeldverhouding van de dataset wijst de preprocessing de samples toe aan de 384×640 bucket die wordt gebruikt door de showcase-run.

Voor beeldtraining produceert preprocessing .pt cachebestanden en gescharde metadata:

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

2. Start training met de bestaande FLUX YAML

Gebruik examples/diffusion/finetune/flux_t2i_flow.yaml direct. De YAML selecteert al FLUX.1-dev, volledige transformer fine-tuning, de FLUX flow-matching adapter, een effectieve batchgrootte van 32 en acht-weg FSDP2.

Geef de tarot-specifieke paden en instellingen op als commandoregel-overrides:

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

De run produceert checkpoints bij stappen 50, 100, 150 en 200. Het laatste checkpoint is gelabeld epoch_66_step_199; het label is nul-gebaseerd, ook al vertegenwoordigt het de voltooide 200e optimizerstap.

3. Genereer vanuit het fijngetunde checkpoint

Gebruik de bestaande FLUX-generatie YAML en wijs model.checkpoint naar het volledige trainingscheckpoint:

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

Voeg trtcrd toe om de geleerde tarotstijl op te roepen. Voor een controlevergelijking, houd het zaad en de scène vast maar laat de trigger weg:

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

Resultaten

Bij stap 200 behouden de getriggerde astronautprompts hun gevraagde inhoud terwijl ze een crème, rode en zwarte vintage palet, zware inktcontouren, platte kleurvelden, verouderde-papier tinten en allegorische kaartcompositie krijgen. De niet-getriggerde astronaut blijft fotografisch, wat aantoont dat het geleerde effect grotendeels geassocieerd is met trtcrd in plaats van het basismodel wereldwijd te vervangen.

Prompt (zaad)BaselineFijngetund (stap 200)Astronaut die een rozentuin op Mars verzorgt (zaad 2026)

4. Prestaties

Alle metingen zijn verzameld op één node met 8× NVIDIA H100 80GB GPU's. Resultaten zijn gemiddelden ± steekproefstandaarddeviatie over drie steady-state 10-stapsvensters.

Tekst-naar-beeld — 512×512

ModelTrainingParallelismeGBS / LBSSteptijdBeelden/sBeelden/s/GPUPeak toegewezen/GPUFLUX.1-devVolledigFSDP232 / 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-ImageVolledigFSDP240 / 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

Tekst-naar-video — 512×512×49 frames

Elk sample is één videoclip van 49 frames.

ModelTrainingGBS / LBSActivation checkpointingSteptijdClips/sClips/s/GPUPeak toegewezen/GPUWan 2.1 1.3BVolledig8 / 1Uit0,942 ± 0,038 s8,50 ± 0,351,06 ± 0,046,09 GiBWan 2.1 14BVolledig8 / 1Aan3,798 ± 0,017 s2,107 ± 0,0060,263 ± 0,00633,35 GiBWan 2.1 14BLoRA r6416 / 2Aan7,585 ± 0,014 s2,110 ± 0,0000,263 ± 0,00024,07 GiBWan 2.2 A14B, hoge ruisVolledig8 / 1Aan4,628 ± 0,031 s1,730 ± 0,0100,217 ± 0,00623,57 GiBHunyuanVideo 1.5Volledig8 / 1Aan5,926 ± 0,046 s1,350 ± 0,0100,170 ± 0,00015,90 GiBHunyuanVideo 1.5LoRA r648 / 1Aan5,575 ± 0,006 s1,433 ± 0,0060,180 ± 0,00010,58 GiB

Meetdetails

  • Hardware: 8× H100 80GB HBM3, volledig NVLink-verbonden.

  • Beelddataset: lambda/naruto-blip-captions, 256 gecachte samples.

  • Videodataset: svjack/Lelouch_Vi_Britannia_FramePack_First_Last_Frame_Video_Captioned, 112 gecachte samples.

  • Volledige batches werden afgedwongen met drop_last=true.

  • Checkpoint-schrijfbewerkingen waren uitgeschakeld.

  • Steptijd omvat dataloading, forward, backward, gradient clipping, optimizer en scheduler werk.

  • Geheugen is piek PyTorch CUDA allocator gebruik, niet totaal NVML apparaatgeheugen.

Andere fijngetunde/LoRA-voorbeelden

De resultaten van fine-tuning en LoRA tonen de kracht van NeMo Automodel voor domeinspecialisatie. Zo paste het fine-tunen van het Wan 2.1-model op een Ghibli-videodataset met succes de uitvoerstijl aan, wat blijkt uit een merkbare verandering in het uiterlijk van een bloem vergeleken met de baseline.

Baseline:

Fijngetund op Ghibli-video's:

We zagen ook de duidelijke impact van het gebruik van LoRA, waarbij het toepassen van de adapter op Wan 2.1 ervoor zorgde dat de video een karakteristieke Ghibli-stijl aannam, vooral zichtbaar in de markering van de ogen van personages.

Geen LoRA:

LoRA:

Deze voorbeelden, inclusief die voor FLUX.2, bevestigen dat gebruikers zowel maximale kwaliteit via volledige fine-tuning als maximale efficiëntie via LoRA-stijl PEFT kunnen bereiken, waarbij de uitvoer wordt afgestemd op specifieke stilistische domeinen.

Probeer het vandaag nog

Lees meer over de integratie en vind meer fine-tuning voorbeelden in de NeMo Automodel-documentatie

Binnenkort: Pythonic recipe APIs

YAML is een goede keuze voor reproduceerbare configuratie, vooral voor teams die bestanden willen die ze kunnen inchecken, beoordelen en hergebruiken, maar veel teams hebben ook een programmatische interface nodig.

In een aanstaande NeMo Automodel-release zijn we van plan om de diffusie-recepten ook via een volledig getypeerde Pythonic API beschikbaar te maken. Gebruikers kunnen dan dezelfde model-, data-, optimizer-, PEFT/LoRA-, parallelisme-, checkpointing- en generatiecomponenten rechtstreeks vanuit Python samenstellen.

Het Pythonic pad is bedoeld om de recepten gemakkelijker te gebruiken vanuit bestaande trainingscode, notebooks en experimentworkflows, en om een eersteklas Pythonic interface te bieden naast het YAML-snelstartpad.