Entraînement Kohya

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

Entraînez LoRA, Dreambooth et des fine-tunes complets pour Stable Diffusion en utilisant le trainer de Kohya.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

Location sur CLORE.AI

1. Visitez CLORE.AI Marketplace

2. Filtrer par type de GPU, VRAM et prix

3. Choisir À 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@<adresse-proxy>

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-tune complet - Entraînement complet du modèle

• LyCORIS - Variantes avancées de LoRA

Exigences

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

Déploiement rapide

Image Docker :

pytorch/pytorch:2.5.1-cuda12.4-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. Aller à la Mes commandes page

2. Cliquez sur votre commande

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

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

Utilisation de l'interface Web

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

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

3. Configurer les paramètres

4. Démarrer l'entraînement

Préparation du jeu de données

Structure des dossiers

/workspace/dataset/
├── 10_mysubject/           # Repeats_conceptname
│   ├── image1.png
│   ├── image1.txt          # Fichier de légende
│   ├── image2.png
│   └── image2.txt
└── 10_regularization/      # Images de régularisation optionnelles
    ├── 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é : Claires, bien éclairées, angles variés

Fichiers de légendes

Créer .txt fichier avec le même nom que l'image :

myimage.txt :

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

Auto-légendage

Utiliser BLIP pour des 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
Rang du réseau	32-128
Alpha du réseau	16-64
Taux d'apprentissage	1e-4
Taille de 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 de 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="a photo of sks person" \
    --class_prompt="a photo of person" \
    --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 de 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="painting in the style of 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
Rang 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

• Utiliser des images de régularisation

• Baisser le taux d'apprentissage

• Moins d'époques

• Augmenter l'alpha du réseau

Éviter le sous-apprentissage

• Plus d'images d'entraînement

• Taux d'apprentissage plus élevé

• Plus d'époques

• Baisser l'alpha du réseau

Surveillance de l'entraînement

TensorBoard

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

Métriques clés

• perte - Devrait diminuer puis se stabiliser

• lr - Plan de taux d'apprentissage

• époque - Progression de l'entraînement

Tester votre LoRA

Avec Automatic1111

Copier le LoRA vers :

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

Utiliser dans le prompt :

<lora:my_lora:0.8> a photo of sks person

Avec ComfyUI

Charger le nœud LoRA et le connecter 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("a photo of sks person, professional portrait").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

# 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 (à partir de 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 40GB	~$0.17	~$4.00	~$0.70
A100 80GB	~$0.25	~$6.00	~$1.00

Les prix varient selon le fournisseur et la demande. Vérifiez CLORE.AI Marketplace pour les tarifs actuels.

Économisez de l'argent :

• Utilisez Spot market pour les charges de travail flexibles (souvent 30-50 % moins cher)

• Payer avec CLORE jetons

• Comparer les prix entre différents fournisseurs

Entraînement FLUX LoRA

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

Exigences VRAM

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

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

Installation pour FLUX

Installer PyTorch avec le support CUDA 12.4 :

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

Configuration FLUX LoRA (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 : utiliser bf16 (PAS fp16 — FLUX exige 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 FLUX LoRA — LR plus faible que 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 dim plus petite fonctionne bien (16-64)
network_alpha = 16         # Mettre égal à 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 optionnel)
sample_every_n_epochs = 5
sample_prompts = "/workspace/sample_prompts.txt"

Commande d'entraînement FLUX LoRA

# 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 (sans 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 : différences clés

Paramètre	SDXL	FLUX.1
Taux d'apprentissage	1e-3 à 1e-4	1e-4 à 5e-5
Précision	fp16 ou bf16	bf16 REQUIS
Module de réseau	networks.lora	networks.lora_flux
Dimension du réseau	32–128	8–64 (plus petit)
Optimiseur	AdamW8bit	Adafactor
VRAM min	12Go	16–24Go
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

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

Tester FLUX LoRA

import torch
from diffusers import FluxPipeline

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

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

image = pipe(
    prompt="a photo of sks person, professional portrait, studio lighting",
    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éduire la taille de batch à 1

• Activer le gradient checkpointing

• Utiliser l'optimiseur 8bit

• Baisser la résolution

Résultats médiocres

• Plus/d'améliorer les images d'entraînement

• Ajuster le taux d'apprentissage

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

• Essayer un rang de réseau différent

Plantages d'entraînement

• Vérifier la version de CUDA

• Mettre à jour xformers

• Réduire la taille de batch

• Vérifier l'espace disque

Problèmes spécifiques à FLUX

• "bf16 non supporté" — Utiliser des GPU A-series (Ampere+) ou séries RTX 30/40

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

• Résultats flous — Augmenter network_dim à 32–64, baisser le taux d'apprentissage à 5e-5

• Perte NaN — Désactiver full_bf16, vérifier votre jeu de données pour des images corrompues