# Entraînement Kohya

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

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Location sur CLORE.AI

1. Visitez [CLORE.AI Marketplace](https://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 :**

```bash
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 :

```python
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

```bash
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)

```bash
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

```bash
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

```bash
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

```bash
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

```python
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)

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

### Inversion textuelle

```bash
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é

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

### Convertir les formats

```python

# 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*](https://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 :

```bash
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)

```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

```bash
# 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

```toml
# 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

```python
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