Entraînement Kohya

Entraînez LoRA et DreamBooth pour Stable Diffusion avec Kohya sur Clore.ai

Entraînez des LoRA, Dreambooth et des fine-tunings complets pour Stable Diffusion en utilisant l’entraîneur de Kohya.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

Louer sur CLORE.AI

1. Visitez la place de marché CLORE.AI

2. Filtrez par type de GPU, VRAM et prix

3. Choisissez À la demande (tarif fixe) ou Spot (prix d'enchère)

4. Configurez votre commande :

   • Sélectionnez l'image Docker

   • Définissez les ports (TCP pour SSH, HTTP pour les interfaces web)

   • Ajoutez des variables d'environnement si nécessaire

   • Entrez la commande de démarrage

5. Sélectionnez le paiement : CLORE, BTC, ou USDT/USDC

6. Créez la commande et attendez le déploiement

Accédez à votre serveur

• Trouvez les détails de connexion dans Mes commandes

• Interfaces web : utilisez l'URL du port HTTP

• SSH : ssh -p <port> root@<proxy-address>

Qu’est-ce que Kohya ?

Kohya_ss est une boîte à outils d’entraînement pour :

• LoRA - Adaptateurs légers (les plus populaires)

• Dreambooth - Entraînement de sujet/style

• Fine-tuning complet - Entraînement complet du modèle

• LyCORIS - Variantes avancées de LoRA

Exigences

Type d’entraînement	VRAM minimale	Recommandé
LoRA SD 1.5	6 Go	RTX 3060
LoRA SDXL	12 Go	RTX 3090
Dreambooth SD 1.5	12 Go	RTX 3090
Dreambooth SDXL	24GB	RTX 4090

Déploiement rapide

Image Docker :

pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel

Ports :

22/tcp
7860/http

Commande :

apt-get update && apt-get install -y git libgl1 libglib2.0-0 && \
cd /workspace && \
git clone https://github.com/bmaltais/kohya_ss.git && \
cd kohya_ss && \
pip install -r requirements.txt && \
pip install xformers && \
python kohya_gui.py --listen 0.0.0.0 --server_port 7860

Accéder à votre service

Après le déploiement, trouvez votre http_pub URL dans Mes commandes:

1. Accédez à Mes commandes la page

2. Cliquez sur votre commande

3. Trouvez le http_pub URL (par ex., abc123.clorecloud.net)

Utilisez https://YOUR_HTTP_PUB_URL au lieu de localhost dans les exemples ci-dessous.

Utilisation de l’interface Web

1. Accédez à http://<proxy>:<port>

2. Sélectionnez le type d’entraînement (LoRA, Dreambooth, etc.)

3. Configurez les paramètres

4. Lancez l’entraînement

Préparation du jeu de données

Structure des dossiers

/workspace/dataset/
├── 10_mysubject/           # Répétitions_nomduconcept
│   ├── image1.png
│   ├── image1.txt          # Fichier de légende
│   ├── image2.png
│   └── image2.txt
└── 10_regularization/      # Images de régularisation facultatives
    ├── reg1.png
    └── reg1.txt

Exigences pour les images

• Résolution : 512x512 (SD 1.5) ou 1024x1024 (SDXL)

• Format : PNG ou JPG

• Quantité : 10 à 50 images pour LoRA

• Qualité : Nettes, bien éclairées, angles variés

Fichiers de légende

Créez un fichier .txt avec le même nom que l’image :

myimage.txt :

une photo de sks person, portrait professionnel, éclairage de studio, haute qualité

Légendage automatique

Utilisez BLIP pour les légendes automatiques :

from transformers import BlipProcessor, BlipForConditionalGeneration
from PIL import Image
import os

processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base").to("cuda")

for img_file in os.listdir("./images"):
    if img_file.endswith(('.png', '.jpg')):
        image = Image.open(f"./images/{img_file}")
        inputs = processor(image, return_tensors="pt").to("cuda")
        output = model.generate(**inputs, max_new_tokens=50)
        caption = processor.decode(output[0], skip_special_tokens=True)

        txt_file = img_file.rsplit('.', 1)[0] + '.txt'
        with open(f"./images/{txt_file}", 'w') as f:
            f.write(caption)

Entraînement LoRA (SD 1.5)

Configuration

Dans l’interface Kohya :

Paramètre	Valeur
Modèle	runwayml/stable-diffusion-v1-5
Rank du réseau	32-128
Alpha du réseau	16-64
Taux d’apprentissage	1e-4
Taille du lot	1-4
Époques	10-20
Optimiseur	AdamW8bit

Entraînement en ligne de commande

accelerate launch --num_cpu_threads_per_process=2 train_network.py \
    --pretrained_model_name_or_path="runwayml/stable-diffusion-v1-5" \
    --train_data_dir="/workspace/dataset" \
    --output_dir="/workspace/output" \
    --output_name="my_lora" \
    --resolution=512 \
    --train_batch_size=1 \
    --max_train_epochs=10 \
    --learning_rate=1e-4 \
    --network_module=networks.lora \
    --network_dim=32 \
    --network_alpha=16 \
    --mixed_precision=fp16 \
    --save_precision=fp16 \
    --optimizer_type=AdamW8bit \
    --lr_scheduler=cosine \
    --cache_latents \
    --xformers \
    --save_every_n_epochs=2

Entraînement LoRA (SDXL)

accelerate launch train_network.py \
    --pretrained_model_name_or_path="stabilityai/stable-diffusion-xl-base-1.0" \
    --train_data_dir="/workspace/dataset" \
    --output_dir="/workspace/output" \
    --output_name="my_sdxl_lora" \
    --resolution=1024 \
    --train_batch_size=1 \
    --max_train_epochs=10 \
    --learning_rate=1e-4 \
    --network_module=networks.lora \
    --network_dim=32 \
    --network_alpha=16 \
    --mixed_precision=bf16 \
    --save_precision=fp16 \
    --optimizer_type=Adafactor \
    --cache_latents \
    --xformers \
    --save_every_n_epochs=2

Entraînement Dreambooth

Entraînement du sujet

accelerate launch train_dreambooth.py \
    --pretrained_model_name_or_path="runwayml/stable-diffusion-v1-5" \
    --instance_data_dir="/workspace/dataset/instance" \
    --class_data_dir="/workspace/dataset/class" \
    --output_dir="/workspace/output" \
    --instance_prompt="une photo de sks person" \
    --class_prompt="une photo d’une personne" \
    --with_prior_preservation \
    --prior_loss_weight=1.0 \
    --num_class_images=200 \
    --resolution=512 \
    --train_batch_size=1 \
    --learning_rate=2e-6 \
    --max_train_steps=1000 \
    --mixed_precision=fp16 \
    --gradient_checkpointing

Entraînement du style

accelerate launch train_dreambooth.py \
    --pretrained_model_name_or_path="runwayml/stable-diffusion-v1-5" \
    --instance_data_dir="/workspace/dataset/style" \
    --output_dir="/workspace/output" \
    --instance_prompt="peinture dans le style de xyz" \
    --resolution=512 \
    --train_batch_size=1 \
    --learning_rate=5e-6 \
    --max_train_steps=2000 \
    --mixed_precision=fp16

Conseils d'entraînement

Paramètres optimaux

Paramètre	Personne/Personnage	Style	Objet
Rank du réseau	64-128	32-64	32
Alpha du réseau	32-64	16-32	16
Taux d’apprentissage	1e-4	5e-5	1e-4
Époques	15-25	10-15	10-15

Éviter le surapprentissage

• Utilisez des images de régularisation

• Baissez le taux d’apprentissage

• Moins d’époques

• Augmentez l’alpha du réseau

Éviter le sous-apprentissage

• Plus d’images d’entraînement

• Taux d’apprentissage plus élevé

• Plus d’époques

• Alpha du réseau plus faible

Surveillance de l'entraînement

TensorBoard

tensorboard --logdir /workspace/output/logs --port 6006 --bind_all

Métriques clés

• perte - Doit diminuer puis se stabiliser

• lr - Planificateur du taux d’apprentissage

• époque - Progression de l’entraînement

Tester votre LoRA

Avec Automatic1111

Copiez la LoRA vers :

stable-diffusion-webui/models/Lora/my_lora.safetensors

Utilisez dans l’invite :

<lora:my_lora:0.8> une photo de sks person

Avec ComfyUI

Chargez le nœud LoRA et connectez-le au modèle.

Avec Diffusers

from diffusers import StableDiffusionPipeline
import torch

pipe = StableDiffusionPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    torch_dtype=torch.float16
).to("cuda")

pipe.load_lora_weights("/workspace/output/my_lora.safetensors")

image = pipe("une photo de sks person, portrait professionnel").images[0]

Entraînement avancé

LyCORIS (LoHa, LoKR)

accelerate launch train_network.py \
    --network_module=lycoris.kohya \
    --network_args "algo=loha" "conv_dim=4" "conv_alpha=2" \
    ...

Inversion textuelle

accelerate launch train_textual_inversion.py \
    --pretrained_model_name_or_path="runwayml/stable-diffusion-v1-5" \
    --train_data_dir="/workspace/dataset" \
    --learnable_property="style" \
    --placeholder_token="<my-style>" \
    --initializer_token="art" \
    --resolution=512 \
    --train_batch_size=1 \
    --max_train_steps=3000 \
    --learning_rate=5e-4

Sauvegarde et exportation

Télécharger le modèle entraîné

scp -P <port> root@<proxy>:/workspace/output/my_lora.safetensors ./

Convertir les formats

# De SafeTensors vers PyTorch
from safetensors.torch import load_file, save_file
import torch

state_dict = load_file("model.safetensors")
torch.save(state_dict, "model.pt")

Estimation des coûts

Tarifs typiques du marché CLORE.AI (en 2024) :

GPU	Tarif horaire	Tarif journalier	Session de 4 heures
RTX 3060	~$0.03	~$0.70	~$0.12
RTX 3090	~$0.06	~$1.50	~$0.25
RTX 4090	~$0.10	~$2.30	~$0.40
A100 40 Go	~$0.17	~$4.00	~$0.70
A100 80 Go	~$0.25	~$6.00	~$1.00

Les prix varient selon le fournisseur et la demande. Vérifiez la place de marché CLORE.AI les tarifs actuels.

Économisez de l'argent :

• Utilisez le Spot marché pour les travaux interrompables — environ un tiers des serveurs ont un prix spot inférieur au tarif à la demande (médiane ~13 % de remise), les autres s'alignent dessus

• Payez avec CLORE jetons

• Comparez les prix entre différents fournisseurs

Entraînement LoRA FLUX

Entraînez des adaptateurs LoRA pour FLUX.1-dev et FLUX.1-schnell — la dernière génération de modèles de transformeur de diffusion avec une qualité supérieure.

Exigences en VRAM

Modèle	VRAM minimale	GPU recommandé
FLUX.1-schnell	16 Go	RTX 4080 / 3090
FLUX.1-dev	24GB	RTX 4090
FLUX.1-dev (bf16)	40 Go+	A100 40 Go

Remarque : FLUX utilise l’architecture DiT (Diffusion Transformer) — la dynamique d’entraînement diffère considérablement de SD 1.5 / SDXL.

Installation pour FLUX

Installez PyTorch avec la prise en charge de CUDA 12.8 :

pip install torch torchvision --index-url https://download.pytorch.org/whl/cu128
pip install xformers --index-url https://download.pytorch.org/whl/cu128
pip install -r requirements.txt
pip install accelerate sentencepiece protobuf

Configuration LoRA FLUX (flux_lora.toml)

[general]
shuffle_caption = false
caption_extension = ".txt"
keep_tokens = 1

[datasets]
[[datasets.subsets]]
image_dir = "/workspace/dataset/train"
caption_extension = ".txt"
num_repeats = 5
resolution = [512, 512]

[training]
pretrained_model_name_or_path = "black-forest-labs/FLUX.1-dev"
output_dir = "/workspace/output"
output_name = "my_flux_lora"

# Spécifique à FLUX : utilisez bf16 (PAS fp16 — FLUX nécessite bf16)
mixed_precision = "bf16"
save_precision = "bf16"
full_bf16 = true

train_batch_size = 1
max_train_epochs = 20
gradient_checkpointing = true
gradient_accumulation_steps = 4

# Paramètres LoRA FLUX — utilisez un LR plus faible que pour SDXL !
learning_rate = 1e-4
lr_scheduler = "cosine_with_restarts"
lr_warmup_steps = 100

# Configuration du réseau
network_module = "networks.lora_flux"
network_dim = 16           # FLUX : une dimension plus petite fonctionne bien (16-64)
network_alpha = 16         # Réglez la même valeur que network_dim

# Options spécifiques à FLUX
t5xxl_max_token_length = 512
apply_t5_attn_mask = true

# Optimiseur — Adafactor fonctionne bien pour FLUX
optimizer_type = "adafactor"
optimizer_args = ["scale_parameter=False", "relative_step=False", "warmup_init=False"]

# Économie de mémoire
cache_latents = true
cache_latents_to_disk = true
cache_text_encoder_outputs = true
cache_text_encoder_outputs_to_disk = true

# Échantillonnage pendant l’entraînement (aperçu facultatif)
sample_every_n_epochs = 5
sample_prompts = "/workspace/sample_prompts.txt"

Commande d’entraînement LoRA FLUX

# GPU unique
accelerate launch train_network.py \
    --config_file flux_lora.toml \
    --network_module networks.lora_flux \
    --network_dim 16 \
    --network_alpha 16 \
    --mixed_precision bf16 \\
    --full_bf16

# Avec paramètres explicites (pas de toml)
accelerate launch train_network.py \
    --pretrained_model_name_or_path "black-forest-labs/FLUX.1-dev" \
    --train_data_dir "/workspace/dataset" \
    --output_dir "/workspace/output" \
    --output_name "my_flux_lora" \
    --network_module networks.lora_flux \
    --network_dim 16 \
    --network_alpha 16 \
    --learning_rate 1e-4 \
    --max_train_epochs 20 \
    --train_batch_size 1 \
    --gradient_accumulation_steps 4 \
    --mixed_precision bf16 \\
    --full_bf16 \
    --optimizer_type adafactor \
    --cache_latents \
    --cache_text_encoder_outputs \
    --t5xxl_max_token_length 512 \
    --apply_t5_attn_mask \
    --save_every_n_epochs 5

FLUX vs SDXL : principales différences

Paramètre	SDXL	FLUX.1
Taux d’apprentissage	1e-3 à 1e-4	1e-4 à 5e-5
Précision	fp16 ou bf16	bf16 OBLIGATOIRE
Module réseau	networks.lora	networks.lora_flux
Dim du réseau	32–128	8–64 (plus petit)
Optimiseur	AdamW8bit	Adafactor
VRAM minimale	12 Go	16–24 Go
Architecture	U-Net	DiT (Transformer)

Guide du taux d’apprentissage pour FLUX

# Conservateur (plus sûr, moins de risque de surapprentissage)
learning_rate = 5e-5

# Standard (bon point de départ)
learning_rate = 1e-4

# Agressif (plus expressif, risque d’artefacts)
learning_rate = 2e-4

Astuce : FLUX est plus sensible au taux d’apprentissage que SDXL. Commencez à 1e-4 et réduisez à 5e-5 si vous voyez des problèmes de qualité. Pour SDXL, 1e-3 est courant — évitez cela pour FLUX.

Tester la LoRA FLUX

import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16,
).to("cuda")

# Chargez votre LoRA entraînée
pipe.load_lora_weights("/workspace/output/my_flux_lora.safetensors")

image = pipe(
    prompt="une photo de sks person, portrait professionnel, éclairage de studio",
    num_inference_steps=28,
    guidance_scale=3.5,
    width=1024,
    height=1024,
).images[0]

image.save("flux_lora_test.png")

---

Dépannage

Erreur OOM

• Réduisez la taille du lot à 1

• Activez le checkpointing des gradients

• Utilisez un optimiseur 8 bits

• Résolution plus faible

Mauvais résultats

• Plus d’images d’entraînement / de meilleures images

• Ajustez le taux d’apprentissage

• Vérifiez que les légendes correspondent aux images

• Essayez un autre rank du réseau

L’entraînement plante

• Vérifiez la version de CUDA

• Mettez à jour xformers

• Réduire la taille du lot

• Vérifiez l'espace disque

Problèmes spécifiques à FLUX

• "bf16 non pris en charge" — Utilisez des GPU des séries A (Ampere+) ou RTX 30/40

• OOM sur FLUX.1-dev — Passez à FLUX.1-schnell (nécessite 16 Go) ou activez cache_text_encoder_outputs

• Résultats flous — Augmentez network_dim à 32–64, baissez le taux d’apprentissage à 5e-5

• Perte NaN — Désactivez full_bf16, vérifiez si votre jeu de données contient des images corrompues