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


---

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

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

The question should be specific, self-contained, and written in natural language.
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.