> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/entrainement/kohya-training.md).

# 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.

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

## Louer sur CLORE.AI

1. Visitez [la place de marché CLORE.AI](https://clore.ai/marketplace)
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 :**

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

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

```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 du 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="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

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

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

```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("une photo de sks person, portrait professionnel").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

# 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*](https://clore.ai/marketplace) *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 :

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

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

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

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

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

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


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/entrainement/kohya-training.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.