Entraîner un LoRA pour SDXL ou pour un petit modèle Flux coûte bien moins de 10 $ sur un GPU loué. En septembre 2026, une RTX 4090 se loue environ 0,31 $ de l’heure sur Vast.ai et 0,74 $ de l’heure sur RunPod, et une session LoRA SDXL, installation et tests compris, prend un peu plus d’une heure. Cela fait 0,34 $ à 0,80 $ par tentative : un budget de 10 $ couvre une douzaine d’essais.
L’argent n’est pas le plus difficile. Les images, les légendes et savoir quand s’arrêter, si. Ce guide couvre tout cela, avec des commandes prêtes à copier. Prix et versions des outils vérifiés en septembre 2026 ; les sources sont en fin d’article.
Le processus en cinq étapes
Ce qu’est un LoRA et pourquoi c’est bon marché
LoRA (Low-Rank Adaptation) gèle le modèle de base et entraîne deux petites matrices à côté de certaines de ses couches. L’article d’origine rapportait 10 000 fois moins de paramètres entraînables et 3 fois moins de mémoire GPU qu’un fine-tuning complet de GPT-3 175B. Les modèles d’image fonctionnent de la même façon : le checkpoint de base SDXL est un fichier de 6,9 Go, tandis que le LoRA que vous entraînez est un petit fichier séparé, chargé par-dessus avec l’intensité de votre choix.
C’est pour cela qu’un seul GPU grand public suffit, et qu’un entraînement se compte en dizaines de minutes plutôt qu’en jours.
Choisir un GPU selon sa VRAM
La VRAM décide de ce que vous pouvez entraîner. La vitesse décide du nombre de minutes facturées : une carte plus rapide et plus chère à l’heure peut revenir à peu près au même prix par entraînement.
| Famille de modèles | Minimum documenté | Confortable | Remarques |
|---|---|---|---|
| SD 1.5 | 8 Go | 12 Go et plus | Entraînement en 512x512, le moins cher et le plus rapide |
| SDXL | 8 Go (10 Go recommandés) | 24 Go | U-Net seul, latents et sorties des encodeurs de texte en cache |
| FLUX.1 [dev] (12B) | 8 Go avec beaucoup de block swapping | 24 Go | sd-scripts documente des réglages pour 24, 16, 12, 10 et 8 Go |
| FLUX.2 [klein] 4B/9B | non précisé | 24 Go | BFL : environ 13 Go de poids bf16, un entraînement LoRA tient sous 24 Go |
Les réglages basse VRAM fonctionnent, mais ils sont lents. C’est en faisant passer des blocs du transformer entre le GPU et la RAM système que sd-scripts fait tenir FLUX.1 dans 8 à 16 Go, et chaque échange coûte du temps que vous payez. Sur une machine louée, une carte de 24 Go est le choix raisonnable par défaut : une RTX 3090 ou 4090. La RTX 5090 (32 Go) convient aussi, mais sd-scripts précise qu’elle demande PyTorch 2.8.0 avec CUDA 12.8 ou 12.9 : vérifiez que votre modèle de déploiement embarque une pile assez récente.

Les cartes de data center sont plus rapides, mais RunPod affiche une A100 80 Go à 1,59 $ de l’heure, plus du double d’une 4090. Pour un LoRA sur 20 ou 30 images, le gain de vitesse compense rarement ; elles ont plus de sens pour de gros jeux de données ou des fine-tunings complets.
Où louer, et combien ça coûte
Il vous faut une plateforme qui vous donne une machine : un shell ou un notebook Jupyter, un disque et un moyen de copier des fichiers dans les deux sens. Vast.ai et RunPod sont les deux choix les plus courants pour ce genre de travail.
| GPU | VRAM | Vast.ai (à partir de) | Page de tarifs RunPod | RunPod, moins cher relevé |
|---|---|---|---|---|
| RTX 3090 | 24 Go | environ 0,11–0,13 $/h | 0,50 $/h | 0,22 $/h |
| RTX 4090 | 24 Go | environ 0,31–0,33 $/h | 0,74 $/h | 0,34 $/h |
| RTX 5090 | 32 Go | environ 0,41–0,47 $/h | 0,99 $/h | 0,69 $/h |
Prix de septembre 2026. Les colonnes « Vast.ai (à partir de) » et « RunPod, moins cher relevé » viennent du suivi de prix de getdeploying.com ; la colonne du milieu vient de la page de tarifs de RunPod. Sur Vast.ai, chaque hôte fixe ses prix : les offres que vous verrez varient selon la localisation et le score de fiabilité.
Les deux facturent à la seconde. Les frais annexes diffèrent, et ils pèsent plus sur une tâche d’une heure que le tarif horaire ne le laisse penser :
- Vast.ai facture le stockage « tant que votre instance existe, quel que soit son état », et facture la bande passante à l’octet, au tarif fixé par chaque hôte. Télécharger un modèle de base de 7 Go chez un hôte à bande passante chère finit par compter. Supprimez l’instance, ne vous contentez pas de l’arrêter.
- RunPod facture le disque de conteneur 0,10 $ par Go et par mois pendant que le pod tourne, rien une fois arrêté, et 0,20 $ par Go et par mois pour un volume disque arrêté. Le transfert de données, entrant comme sortant, est gratuit.
Les deux proposent des modèles de déploiement prêts à l’emploi. L’auteur d’ai-toolkit maintient un modèle RunPod officiel, et le README de kohya_ss cite RunPod parmi les configurations prises en charge. Un modèle de déploiement vous épargne au moins dix minutes d’installation de PyTorch sur du temps facturé. Pour une comparaison de prix plus large, voir GPUFlow, Vast.ai, RunPod et SaladCloud comparés et le vrai coût de la location d’un GPU.
Préparer les images et les légendes
Faites tout cela sur votre propre ordinateur, avant de louer quoi que ce soit.
Les images
- Le nombre. 15 à 40 images pour une personne, un objet ou un style. Black Forest Labs recommande « 15 à 40 images qui partagent un même rendu » pour FLUX.2 [klein]. Plus n’est pas mieux si les images en plus sont moins bonnes.
- Cohérence et variété. Chaque image doit montrer le concept. Tout le reste doit varier : angle, éclairage, arrière-plan, cadrage. Si toutes les photos de votre produit le montrent sur la même table blanche, le LoRA apprend la table.
- La qualité. Nettes, bien exposées, sans filigrane ni texte incrusté. Le LoRA apprend le bruit et les artefacts JPEG aussi fidèlement que le reste.
- La résolution. Au moins 1024 pixels sur le petit côté pour SDXL et Flux, 512 pour SD 1.5. Inutile de recadrer en carré : avec le bucketing activé, sd-scripts regroupe les images par format.
Les légendes
Chaque image a un fichier texte du même nom (photo01.jpg, photo01.txt). La légende indique au modèle ce que les mots expliquent déjà, pour que le LoRA apprenne ce qu’ils n’expliquent pas. Placez d’abord un mot déclencheur rare, puis décrivez tout ce qui doit rester modifiable :
zxq_mug, a ceramic coffee mug on a wooden desk, morning light from the left, shallow depth of field
Deux outils écrivent un premier jet à votre place :
-
WD14 tagger, fourni avec sd-scripts, produit des tags séparés par des virgules. Bien adapté aux modèles de style anime et aux fine-tunes SDXL entraînés sur des tags :
python finetune/tag_images_by_wd14_tagger.py --onnx \ --repo_id SmilingWolf/wd-swinv2-tagger-v3 --batch_size 4 /workspace/dataset/img -
JoyCaption, un modèle de légendage ouvert (Apache 2.0) conçu pour l’entraînement de modèles de diffusion, écrit des phrases en langage naturel, qui conviennent mieux à Flux que des tags. Son README indique qu’il demande environ 17 Go de VRAM en bf16, avec des versions 8 bits et 4 bits pour les cartes plus petites.
OneTrainer intègre aussi le légendage avec BLIP, BLIP2 et WD-1.4. Quel que soit l’outil qui écrit le premier jet, relisez chaque légende et corrigez-la. C’est la demi-heure la plus rentable de tout le projet.
Choisir un outil d’entraînement
Quatre outils couvrent presque tous les besoins. Tous sont gratuits et open source.
| Outil | Interface | Modèles (septembre 2026) | Bien pour |
|---|---|---|---|
| kohya-ss/sd-scripts | Ligne de commande | SD 1.x/2.x, SDXL, SD3/3.5, FLUX.1, Lumina, HunyuanImage-2.1, Anima | Entraînements reproductibles, contrôle total |
| bmaltais/kohya_ss | Interface web par-dessus sd-scripts | Les mêmes que sd-scripts | sd-scripts sans retenir les options |
| Nerogar/OneTrainer | Interface de bureau et CLI | SD 1.5 à 3.5, SDXL, FLUX.1, FLUX.2, Chroma, Qwen Image et d’autres | Légendage et masquage intégrés |
| ostris/ai-toolkit | Interface web et configurations YAML | SD 1.5, SDXL, FLUX.1, FLUX.2, Qwen-Image, vidéo Wan et d’autres | Flux et modèles récents, modèle RunPod |
sd-scripts en est à la version 0.11.1 (juin 2026), est testé avec Python 3.10 et demande PyTorch 2.6.0 ou plus récent. ai-toolkit recommande Python 3.12 et installe actuellement PyTorch 2.13.0 compilé pour CUDA 13.0. OneTrainer demande Python 3.10 à 3.13.
J’utilise sd-scripts pour SDXL, parce que la ligne de commande contient toute la configuration, ce qui rend les entraînements faciles à refaire et à comparer, et ai-toolkit pour Flux.
Entraîner un LoRA SDXL avec sd-scripts
Sur une instance Linux neuve avec un pilote NVIDIA, l’installation tient en quelques commandes :
git clone https://github.com/kohya-ss/sd-scripts.git
cd sd-scripts
python -m venv venv && source venv/bin/activate
pip install torch==2.6.0 torchvision==0.21.0 --index-url https://download.pytorch.org/whl/cu124
pip install --upgrade -r requirements.txt
accelerate config default --mixed_precision bf16
# SDXL base model (not gated, CreativeML Open RAIL++-M license)
hf download stabilityai/stable-diffusion-xl-base-1.0 sd_xl_base_1.0.safetensors \
--local-dir /workspace/models
Copiez votre dossier d’images et de légendes .txt dans /workspace/dataset/img avec scp, rsync ou le navigateur de fichiers de la plateforme. Décrivez ensuite le jeu de données dans /workspace/dataset.toml :
[general]
caption_extension = ".txt"
enable_bucket = true
[[datasets]]
resolution = 1024
batch_size = 1
[[datasets.subsets]]
image_dir = "/workspace/dataset/img"
num_repeats = 10
Puis lancez l’entraînement :
accelerate launch --num_cpu_threads_per_process 1 sdxl_train_network.py \
--pretrained_model_name_or_path=/workspace/models/sd_xl_base_1.0.safetensors \
--dataset_config=/workspace/dataset.toml \
--output_dir=/workspace/output --output_name=zxq_mug \
--save_model_as=safetensors \
--network_module=networks.lora --network_dim=16 --network_alpha=8 \
--network_train_unet_only \
--optimizer_type=AdamW8bit --learning_rate=1e-4 \
--lr_scheduler=constant_with_warmup --lr_warmup_steps=100 \
--max_train_epochs=8 --save_every_n_epochs=2 \
--mixed_precision=bf16 --save_precision=bf16 \
--cache_latents --cache_latents_to_disk --cache_text_encoder_outputs \
--gradient_checkpointing --sdpa --seed=42 \
--sample_prompts=/workspace/prompts.txt --sample_every_n_epochs=2
prompts.txt contient un prompt de test par ligne, avec les options en ligne de sd-scripts pour la taille, la seed et le nombre de pas :
zxq_mug, a ceramic coffee mug on a kitchen counter --w 1024 --h 1024 --d 42 --s 28
zxq_mug, a ceramic coffee mug held by a hiker on a mountain top --w 1024 --h 1024 --d 42 --s 28
Ce que font les réglages
- Les pas. Images × répétitions × époques ÷ taille de batch. Avec 25 images : 25 × 10 × 8 = 2 000 pas.
network_dim16,network_alpha8. La capacité du LoRA. 16 suffit largement pour un objet ou un visage ; un style demande parfois 32. Un rang plus élevé surapprend plus vite et produit des fichiers plus gros.--network_train_unet_only. Obligatoire ici : sd-scripts refuse de mettre en cache les sorties des encodeurs de texte tout en entraînant ces encodeurs, et sa documentation qualifie de toute façon l’entraînement du U-Net seul de « fortement recommandé » pour les LoRA SDXL.- Mise en cache et gradient checkpointing. C’est ce qui fait tenir SDXL dans 8 à 10 Go. La mise en cache désactive aussi le mélange et l’abandon aléatoire des légendes (caption shuffle et caption dropout), d’où leur absence du fichier de jeu de données.
learning_rate1e-4 avec AdamW8bit. La valeur de l’exemple LoRA SDXL de sd-scripts. Si les images d’essai bougent à peine après quatre époques, essayez 2e-4. Si elles deviennent des copies de vos images d’entraînement, baissez-la ou arrêtez plus tôt.- Un checkpoint toutes les 2 époques. Vous obtenez des fichiers pour les époques 2, 4, 6 et 8, et vous gardez le meilleur. Le meilleur LoRA n’est souvent pas le dernier.
Combien de temps ça prend
Des utilisateurs, dans un ticket de kohya_ss, ont rapporté environ 1,1 à 1,4 itération par seconde pour un entraînement LoRA SDXL en 1024x1024, batch de 1, sur une RTX 4090 avec gradient checkpointing. À cette vitesse, 2 000 pas prennent 24 à 30 minutes, plus quelques minutes pour mettre les latents en cache. Le même ticket montre à quel point tout se dégrade quand une carte manque de VRAM et déborde sur la mémoire partagée : 50 secondes ou plus par pas. Si votre vitesse est très en dessous de la fourchette attendue, regardez nvidia-smi avant d’accuser les réglages.
Flux et les modèles récents avec ai-toolkit
Pour Flux, ai-toolkit est la voie la plus simple. Sur une machine louée :
git clone https://github.com/ostris/ai-toolkit.git
cd ai-toolkit
python3 -m venv venv && source venv/bin/activate
pip3 install --no-cache-dir torch==2.13.0 torchvision==0.28.0 torchaudio==2.11.0 \
--index-url https://download.pytorch.org/whl/cu130
pip3 install -r requirements.txt
cp config/examples/train_lora_flux_24gb.yaml config/zxq_mug.yml
# edit the dataset path, trigger word and steps, then:
python run.py config/zxq_mug.yml
Vous pouvez aussi lancer l’interface web avec cd ui && npm run build_and_start et ouvrir le port 8675. Sur un serveur accessible par d’autres, définissez d’abord un mot de passe dans AI_TOOLKIT_AUTH, comme le recommande le README.
Deux points de licence à connaître avant de choisir un modèle Flux :
- FLUX.1 [dev] est en accès restreint sur Hugging Face. Vous acceptez la FLUX.1 [dev] Non-Commercial License et utilisez un token de lecture Hugging Face pour le télécharger. Sa fiche de modèle indique que les images générées peuvent être utilisées commercialement ; les poids et votre LoRA relèvent de la licence non commerciale.
- FLUX.2 [klein] 4B est sous Apache 2.0 et en libre accès. La version 9B utilise la FLUX Non-Commercial License.
Black Forest Labs a publié en juin 2026 un guide pour entraîner des LoRA FLUX.2 [klein] avec ai-toolkit : un entraînement de 1 800 pas sur une RTX 4090 « prend moins d’une heure », et ils conseillent de regarder les checkpoints entre les pas 750 et 1 500. Je n’ai pas trouvé de mesure publiée aussi solide pour FLUX.1 [dev], trois fois plus gros que klein 4B ; prévoyez plus de temps et chronométrez votre premier entraînement.
Tester le LoRA avant d’arrêter de payer
Regardez les images d’essai de chaque époque sauvegardée pendant que la machine tourne encore. Elles vous montrent, sans frais, si le LoRA a appris le concept et à partir de quand il a commencé à surapprendre. Téléchargez ensuite les checkpoints qui vous plaisent :
rsync -avP user@your-instance:/workspace/output/*.safetensors ./loras/
Chez vous, placez le fichier dans le dossier models/loras de ComfyUI ou models/Lora de Forge, et testez avec des seeds fixes :
- L’intensité. Essayez 0,6, 0,8 et 1,0. Certains LoRA rendent mieux sous 1,0.
- La souplesse. Placez le déclencheur dans des scènes absentes de vos données. Une tasse au sommet d’une montagne, un visage dans un tableau. S’il ne fonctionne que dans des scènes proches des images d’entraînement, il a surappris : prenez une époque antérieure ou moins de répétitions.
- Les fuites. Générez sans le mot déclencheur. Si le concept apparaît quand même, vos légendes ne décrivaient pas assez l’image.
Quand le résultat ne va pas, la correction se trouve en général dans les données : quelques images faibles retirées, ou des légendes qui nomment ce que vous voulez faire varier. Changer le taux d’apprentissage vient en second, pas en premier.
Le calcul du coût
Un LoRA SDXL, 25 images, 2 000 pas, sur une RTX 4090 :
| Étape | Durée |
|---|---|
| Partir d’un modèle de déploiement, installer sd-scripts | 10 min |
| Télécharger SDXL base, envoyer les images, mise en cache | 10 min |
| Entraînement (2 000 pas à 1,1–1,4 it/s) | 30 min |
| Regarder les essais, télécharger les checkpoints, supprimer l’instance | 15 min |
| Total | 65 min (1,08 h) |
- Vast.ai à 0,31 $/h : 1,08 × 0,31 $ = 0,34 $, plus le stockage et le tarif de bande passante de l’hôte.
- RunPod à 0,74 $/h : 1,08 × 0,74 $ = 0,80 $. Un disque de conteneur de 50 Go pendant cette heure ajoute 50 × 0,10 $ ÷ 730 heures, soit moins d’un cent.
Un LoRA FLUX.2 [klein] avec une heure d’entraînement et 30 minutes d’installation et de tests revient à 1,5 × 0,74 $ = 1,11 $ sur RunPod, ou 1,5 × 0,31 $ = 0,47 $ sur Vast.ai.
Ce qui fait vraiment exploser un budget de 10 $, c’est rarement l’entraînement. C’est une instance restée allumée toute la nuit (12 heures à 0,74 $ font 8,88 $), une instance Vast.ai arrêtée qui paie encore son stockage, ou une heure passée à légender des images sur du temps facturé. La facturation à la seconde n’aide que si vous supprimez la machine quand vous avez fini.
Et GPUFlow dans tout ça
Pour ce travail, GPUFlow ne convient pas. Il loue l’accès à un modèle de langage qu’un fournisseur sert (généralement avec Ollama) sur son propre GPU, via une clé API compatible OpenAI. Il n’y a ni shell, ni SSH, ni accès aux fichiers : impossible d’installer un outil d’entraînement, d’envoyer des images ou de récupérer un LoRA. Et il sert des modèles de chat, pas des modèles d’image. Entraînez sur Vast.ai, RunPod ou une plateforme similaire qui vous loue la machine.
Si vous travaillez sur du texte plutôt que sur des images, la même méthode (louer, entraîner, supprimer) s’applique aux modèles de langage : voir fine-tuner un LLM en privé sur un GPU loué.
Sources
Toutes vérifiées en septembre 2026.
- Article LoRA : Hu et al., LoRA: Low-Rank Adaptation of Large Language Models
- sd-scripts : README et versions, entraînement LoRA SDXL, notes SDXL et VRAM, configuration du jeu de données, entraînement LoRA FLUX.1, WD14 tagger
- bmaltais/kohya_ss, Nerogar/OneTrainer, ostris/ai-toolkit, JoyCaption
- Vitesses SDXL sur 4090 : ticket kohya_ss n° 1288
- Black Forest Labs : fine-tuner FLUX.2 [klein] avec un LoRA en moins de 60 minutes, fiches de modèle de FLUX.1 [dev], FLUX.2 [klein] 4B, FLUX.2 [klein] 9B
- Fiche de modèle Stable Diffusion XL base 1.0
- Prix : tarifs RunPod, tarifs des pods et stockage RunPod, tarifs Vast.ai, getdeploying.com pour la RTX 3090, la RTX 4090, la RTX 5090 et Vast.ai
- GPUFlow : démarrage rapide de l’API