Hoe train je een Flux LoRA (Flux.1 en Flux 2): de stapsgewijze beginnershandleiding

Flux LoRA training is hoe je het Flux beeldmodel iets leert wat het nog niet weet: je gezicht, je product, je tekenstijl, een camera-look. Het resultaat is één .safetensors-bestand van 20 tot 300 MB dat je in elke Flux-app kunt gebruiken, inclusief Graydient. Het proces kost 15 tot 30 foto's, een kaart met 12 tot 16 GB geheugen (of een gehuurde voor een uur) en een gratis trainer. Deze gids doorloopt elke stap voor Flux.1 dev en voor Flux 2, en eindigt met hoe je je nieuwe LoRA hier kunt gebruiken.

Je doet zeven dingen: kies de Flux basis, bouw een kleine dataset, schrijf bijschriften, kies een trainer, stel een paar getallen in, train en test, en importeer dan het bestand in Graydient. Elke stap is hieronder uitgeschreven met de waarden die voor de meeste mensen werken. Heb je al een getraind bestand, ga dan naar het gedeelte over het gebruik ervan.

Graydient draait LoRA's; het traint ze niet. Training gebeurt op je eigen grafische kaart, op een GPU die je per uur huurt, of in een online trainer. Zodra het bestand bestaat, kan elk Graydient-abonnement ermee renderen voor één vaste prijs.

Wat je nodig hebt

• 15 tot 30 goede foto's van één onderwerp, of 30 tot 60 voor een stijl. Telefoonfoto's zijn prima als ze scherp en gevarieerd zijn.
• Een grafische kaart met 12 tot 16 GB geheugen voor Flux.1 dev of Flux 2 Klein 4B, of 24 GB en meer voor Flux 2 dev. Geen kaart? Huur er een voor een uur (zie hieronder) of gebruik een online trainer.
• Een gratis trainer: AI Toolkit, Kohya sd-scripts (of de FluxGym-interface erbovenop) of OneTrainer. Allemaal werken op Windows en Linux met Python geïnstalleerd.
• Één tot drie uur, het grootste deel wacht je. Een Graydient-abonnement is alleen belangrijk aan het eind, wanneer je met het bestand wilt renderen. Vergelijk plannen en prijzen.

Stap 1: kies de Flux basis om op te trainen

Een LoRA is gebonden aan het basismodel waarop het getraind is, dus begin met de basis waarmee je wilt renderen. De Flux-familie heeft drie takken die geen LoRA's delen:

De regel om te onthouden: Flux.1 LoRA's werken niet op Flux 2, Flux 2 LoRA's werken niet op Flux.1, en Klein 4B, Klein 9B en Flux 2 dev hebben elk hun eigen LoRA nodig. Krea 2 is een ander model, geen Flux. Gebruik je meerdere bases, train dan één keer per basis met dezelfde dataset.

Stap 2: bouw de dataset

Flux leert snel van kleine, schone datasets. Kwaliteit gaat boven kwantiteit; 20 scherpe en gevarieerde foto's zijn beter dan 80 bijna-dubbele.

1. Verzamel 15 tot 30 foto's van een persoon, product of object. Verander de hoek, afstand, verlichting en achtergrond tussen de foto's. Zorg dat minstens een derde close-ups zijn en een derde hele lichaam of heel product.
2. Voor een stijl verzamel je 30 tot 60 werken met hetzelfde medium en lijnkwaliteit maar verschillende onderwerpen: mensen, plaatsen, objecten. De variatie vertelt de trainer dat het onderwerp niet de stijl is.
3. Verwijder wazige beelden, zware compressie, watermerken, tekstoverlays en iedereen die niet het onderwerp is. Eén afwijkend gezicht in de set verschijnt in renders.
4. Resolutie: 1024 pixels aan de lange kant is de standaard voor Flux. Houd de beeldverhoudingen gemengd; elke trainer sorteert ze automatisch. Rek de foto's niet uit tot vierkanten.
5. Zet de foto's in één map met naast elke foto een tekstbestand met dezelfde naam. Het bijschrift komt in het tekstbestand: dataset/01.jpg dataset/01.txt dataset/02.jpg dataset/02.txt

Stap 3: schrijf de bijschriften

Flux leest natuurlijke zinnen via zijn T5-tekstencoder, dus bijschriften zijn gewone beschrijvingen, geen lijst met trefwoorden. De bijschriften bepalen wat de LoRA leert en wat het laat:

• Voor een onderwerp begin je met een triggerwoord dat geen echt woord is, beschrijf dan alles wat niet het onderwerp is: kleding, pose, plaats, licht. De trainer leert dat het triggerwoord het deel is dat het bijschrift niet uitlegt.
• Voor een stijl beschrijf je de inhoud van elke foto en nooit de stijl. De stijl leert de LoRA door weglating, en die past het dan toe op elk onderwerp dat je prompt.
• Houd bijschriften op één of twee zinnen. Auto-bijschrijf met Florence-2 of JoyCaption als je meer dan 30 foto's hebt, lees en verbeter dan de eerste tien met de hand.
• Gebruik geen echte persoonsnaam als triggerwoord en beschrijf geen dingen die niet op de foto staan.

Een onderwerpbijschrift voor een persoon-LoRA: ohwx woman, wearing a grey wool coat, standing on a stone bridge, overcast daylight, looking at the camera

Een bijschrift voor een stijl-LoRA, waarbij de stijl bewust niet genoemd wordt: a fishing boat in a harbour at dawn, two men on the pier, fog over the water

Stap 4: kies een trainer

Vier gratis, open-source trainers dekken elke Flux basis. Ze gebruiken allemaal dezelfde datasetmap en produceren hetzelfde soort .safetensors-bestand:

• AI Toolkit (door ostris): de meest gebruikte Flux trainer. Eén YAML-configuratiebestand per run, een webinterface, laag-VRAM-modi en ondersteuning voor Flux.1 dev, Flux 2 dev en Flux 2 Klein. Start de run met python run.py config/my_flux_lora.yaml. De beste eerste keuze.
• Kohya sd-scripts en FluxGym: Kohya is de ervaren trainer achter de meeste Stable Diffusion LoRA's en heeft een Flux-branch. FluxGym is een één-pagina webinterface erbovenop met 12, 16 en 20 GB presets. Handig als je een formulier wilt invullen, niet een bestand wilt bewerken.
• OneTrainer: een desktopapplicatie met een vriendelijke interface voor SDXL en Flux.1. Kies dit als je ook SDXL LoRA's traint en één tool wilt.
• Online trainers: Civitai's on-site trainer en de Flux trainers op GPU-hosting sites nemen een zip met foto's en geven een bestand terug. Ze kosten credits per run en verbergen de instellingen, maar je hebt helemaal geen kaart nodig. Het bestand dat ze produceren importeer je op dezelfde manier in Graydient.

Stap 5: stel de vijf belangrijke getallen in

Elke trainer heeft tientallen opties. Laat de standaardwaarden staan behalve deze, die bepalen hoe sterk, hoe algemeen en hoe groot de LoRA is:

Stel de trainer in om elke 250 stappen een checkpoint op te slaan en bij elke opslag twee voorbeeldafbeeldingen te renderen met dezelfde prompt en seed. Deze voorbeelden gebruik je om de winnaar te kiezen. Flux.1 dev en Flux 2 dev zijn guidance-distilled; de trainers regelen dat voor je, dus laat de guidance-instelling op standaard staan.

Stap 6: trainen

1. Start de run en houd het geheugen de eerste minuut in de gaten. Als het de kaart vult en overschrijdt naar het systeemgeheugen, stop dan: trainen duurt dan tien keer langer en kan crashen.
2. Als het geheugen overschrijdt, schakel dan de basis over naar fp8, zet gradient checkpointing aan, gebruik de 8-bit AdamW of Adafactor optimizer, verlaag de resolutie naar 768 en houd de batch op 1. Elk van deze bespaart gigabytes.
3. Als het eenmaal soepel draait, laat het dan met rust. Flux.1 dev duurt één tot twee uur voor 1500 stappen op een 16 GB kaart; Klein 4B is sneller; Flux 2 dev duurt ongeveer een uur op een gehuurde 48 GB kaart.
4. Bekijk de voorbeeldafbeeldingen zodra ze verschijnen. Het onderwerp verschijnt meestal rond stap 500 en is solide rond 1000. Als het perfect is bij 750, kun je eerder stoppen.

Training is traag en ruisend, niet fragiel. Een run die de eerste minuut overleeft, maakt bijna altijd de finish. Cache de latents en tekst-embeddings voor het trainen als je trainer dat aanbiedt; dat bespaart geheugen en tijd bij elke run.

Stap 7: testen en het juiste checkpoint kiezen

Het laatste checkpoint is zelden het beste. Overgetrainde LoRAs kopiëren de achtergronden van de dataset, verbranden het contrast en negeren prompts. Test ze allemaal:

• Schrijf vier prompts die niet in de dataset voorkomen: een nieuwe plek, een nieuwe outfit, een ander licht, een ander medium. Zet de seed vast.
• Render elk opgeslagen checkpoint met de vier prompts op LoRA-gewichten 0.6, 0.8 en 1.0.
• Kies het vroegste checkpoint dat het onderwerp goed raakt en nog steeds de nieuwe prompts volgt. Latere zijn meestal overbewerkt; eerdere zijn vaag.
• Hernoem de winnaar naar iets dat je over een jaar in een bibliotheek herkent, zoals het onderwerp en de basis: mijn-flux-lora, niet lora_000750.

Geen grafische kaart? Huur er een voor een uur

Flux 2 dev training, of elke Flux training op een laptop, is goedkoper op een gehuurde kaart dan op je eigen tijd. Een 24 of 48 GB kaart kost ruim onder de prijs van een koffie per uur op GPU-verhuurmarkten, en een Flux LoRA heeft één tot twee uur nodig.

• Huur een machine met een 24 GB kaart voor Flux.1 dev of Klein, 48 GB voor Flux 2 dev. Kies een template met de trainer vooraf geïnstalleerd als die beschikbaar is; AI Toolkit templates zijn gebruikelijk.
• Upload de datasetmap, gebruik dezelfde instellingen als hierboven, en download de checkpoints die je wilt testen. De dataset en de gewichten blijven van jou.
• Stop de machine als de download klaar is. Het hele proces, inclusief setup, duurt meestal minder dan twee uur huur.

Gebruik je Flux LoRA op Graydient

Graydient heeft het bestand niet op je computer nodig om ermee te renderen. Zet het waar Graydient het kan ophalen en importeer de link:

1. Upload het .safetensors bestand naar een repository in je Hugging Face account (publiek of privé), of publiceer het op Civitai met het basismodel ingesteld op de Flux-versie waarop je getraind hebt.
2. inloggen bij Graydient, open Model Import vanuit je dashboardbibliotheek en plak de directe bestandslink van Hugging Face of de Civitai-pagina link. De volledige stappen staan in hoe Civitai modellen te importeren op Graydient.
3. Wacht tot de LoRA in je bibliotheek verschijnt en kopieer de ShortCode die Graydient eraan gaf.
4. Render met de LoRA-tag en de bijpassende basis in elke Graydient-app: <lora:my-flux-lora:0.8> <flux-dev> voor een Flux.1 LoRA, of <lora:my-flux2-lora:0.8> <flux2> voor een Flux 2 LoRA. Elke app, gewicht en stapelregel staat in de beginnersgids voor Flux en Flux 2 LoRAs op Graydient.

Een complete eerste render voor Telegram of Discord, met het triggerwoord eerst en de LoRA op 0.8 op de Flux dev basis: /render ohwx woman, portrait, soft window light, 85mm photo <lora:my-flux-lora:0.8> <flux-dev> /steps:24 /guidance:3.5 /size:1024x1024

Licenties: wat je met de LoRA mag doen

Een LoRA is een afgeleide van zijn basismodel, dus de basislicentie geldt ook. Controleer de actuele licentietekst op de modelpagina voordat je renders of het bestand verkoopt:

• Flux.1 dev en Flux 2 dev zijn uitgebracht onder de niet-commerciële licentie van Black Forest Labs. Persoonlijke projecten en onderzoek zijn toegestaan; commercieel gebruik vereist hun commerciële licentie.
• Flux 2 Klein 4B (en zijn Base checkpoint) is Apache 2.0, dus LoRAs getraind daarop hebben geen basismodelrestrictie. Klein 9B valt onder de niet-commerciële licentie.
• De afbeeldingen in je dataset hebben hun eigen rechten. Train op foto’s die je zelf hebt gemaakt of bezit, en nooit op een echt persoon zonder hun toestemming.

Als er iets misgaat

• Geheugen vol in de eerste minuut: de basis in fp16 plus de optimizer past niet. Schakel over naar fp8, 8-bit AdamW of Adafactor, gradient checkpointing, resolutie 768, batch 1. Als het nog steeds overschrijdt, huur dan een kaart.
• De LoRA verandert het hele plaatje, niet alleen het onderwerp: de bijschriften beschreven de achtergrond en het licht niet, dus leerde de trainer die als onderdeel van het triggerwoord. Herbeschrijf met de context duidelijk en varieer de dataset.
• Het gezicht klopt bij gewicht 1.0 maar prompts worden genegeerd: overgetraind. Gebruik een eerder checkpoint. Volgende run, halveer de stappen of verlaag de leersnelheid naar 5e-5.
• Alleen een vage gelijkenis bij elk gewicht: ondergetraind, of de dataset is te uniform. Voeg stappen toe in blokken van 500, of voeg plaatjes met nieuwe hoeken toe.
• De LoRA doet niets op Graydient: de basis komt niet overeen. Een Flux.1 LoRA heeft <flux-dev> nodig; een Flux 2 LoRA heeft <flux2> nodig. Controleer ook dat het triggerwoord in de prompt staat.
• Training draait maar is pijnlijk traag: het overschrijdt naar systeemgeheugen, of de dataset staat op een trage schijf. Los het geheugenprobleem op zoals in het eerste punt, cache latents, en verplaats de dataset naar een SSD.

Dat is de hele methode: één basis, 20 schone plaatjes, eerlijke bijschriften, vijf getallen, een run, een test. Je eerste Flux LoRA wordt niet je beste, en de tweede kost de helft van de tijd. Als het bestand bestaat, inloggen bij Graydient of vergelijk plannen en prijzen om er zo vaak mee te renderen als je wilt. Elk plan heeft een 7-daagse geld-terug-garantie.

Vragen

Bekijk plannen en prijzen