> 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-hi/training/kohya-training.md).

# Kohya ट्रेनिंग

Clore.ai पर Kohya के साथ Stable Diffusion के लिए LoRA और DreamBooth ट्रेन करें

Kohya के ट्रेनर का उपयोग करके Stable Diffusion के लिए LoRA, Dreambooth, और पूर्ण फाइन-ट्यून ट्रेन करें।

{% hint style="success" %}
सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं, जिन्हें किराए पर लिया गया है [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace).
{% endhint %}

## CLORE.AI पर किराए पर लेना

1. विज़िट करें [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace)
2. GPU प्रकार, VRAM और कीमत के अनुसार फ़िल्टर करें
3. चुनें **ऑन-डिमांड** (स्थिर दर) या **स्पॉट** (बोली मूल्य)
4. अपना ऑर्डर कॉन्फ़िगर करें:
   * Docker इमेज चुनें
   * पोर्ट सेट करें (SSH के लिए TCP, वेब UI के लिए HTTP)
   * यदि आवश्यक हो तो environment variables जोड़ें
   * स्टार्टअप कमांड दर्ज करें
5. भुगतान चुनें: **CLORE**, **BTC**या **USDT/USDC**
6. ऑर्डर बनाएं और डिप्लॉयमेंट की प्रतीक्षा करें

### अपने सर्वर तक पहुँचें

* कनेक्शन विवरण यहाँ खोजें **मेरे ऑर्डर**
* वेब इंटरफ़ेस: HTTP पोर्ट URL का उपयोग करें
* SSH: `ssh -p <port> root@<proxy-address>`

## Kohya क्या है?

Kohya\_ss इनके लिए एक प्रशिक्षण टूलकिट है:

* **LoRA** - हल्के अडैप्टर (सबसे लोकप्रिय)
* **Dreambooth** - विषय/शैली प्रशिक्षण
* **पूर्ण फाइन-ट्यून** - पूर्ण मॉडल प्रशिक्षण
* **LyCORIS** - उन्नत LoRA वेरिएंट

## आवश्यकताएँ

| प्रशिक्षण प्रकार  | न्यूनतम VRAM | अनुशंसित |
| ----------------- | ------------ | -------- |
| LoRA SD 1.5       | 6GB          | RTX 3060 |
| LoRA SDXL         | 12GB         | RTX 3090 |
| Dreambooth SD 1.5 | 12GB         | RTX 3090 |
| Dreambooth SDXL   | 24GB         | RTX 4090 |

## त्वरित डिप्लॉय

**Docker इमेज:**

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

**पोर्ट:**

```
22/tcp
7860/http
```

**कमांड:**

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

## अपनी सेवा तक पहुँचना

डिप्लॉयमेंट के बाद, अपना `http_pub` URL यहाँ **मेरे ऑर्डर**:

1. पर जाएँ **मेरे ऑर्डर** पेज
2. अपने ऑर्डर पर क्लिक करें
3. खोजें `http_pub` URL (उदा., `abc123.clorecloud.net`)

उपयोग करें `https://YOUR_HTTP_PUB_URL` की बजाय `localhost` नीचे दिए गए उदाहरणों में।

## वेब UI का उपयोग करना

1. यहाँ एक्सेस करें `http://<proxy>:<port>`
2. प्रशिक्षण प्रकार चुनें (LoRA, Dreambooth, आदि)
3. सेटिंग्स कॉन्फ़िगर करें
4. प्रशिक्षण शुरू करें

## डेटासेट तैयारी

### फ़ोल्डर संरचना

```
/workspace/dataset/
├── 10_mysubject/           # repeats_conceptname
│   ├── image1.png
│   ├── image1.txt          # कैप्शन फ़ाइल
│   ├── image2.png
│   └── image2.txt
└── 10_regularization/      # वैकल्पिक रेगुलराइज़ेशन इमेजें
    ├── reg1.png
    └── reg1.txt
```

### इमेज आवश्यकताएँ

* **रिज़ॉल्यूशन:** 512x512 (SD 1.5) या 1024x1024 (SDXL)
* **फ़ॉर्मेट:** PNG या JPG
* **मात्रा:** LoRA के लिए 10-50 इमेजें
* **गुणवत्ता:** साफ़, अच्छी रोशनी वाली, विभिन्न कोणों से

### कैप्शन फ़ाइलें

बनाएँ `.txt` इमेज के समान नाम वाली फ़ाइल:

**myimage.txt:**

```
sks व्यक्ति की एक तस्वीर, पेशेवर पोर्ट्रेट, स्टूडियो लाइटिंग, उच्च गुणवत्ता
```

### ऑटो-कैप्शनिंग

स्वचालित कैप्शन के लिए BLIP का उपयोग करें:

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

## LoRA प्रशिक्षण (SD 1.5)

### कॉन्फ़िगरेशन

**Kohya UI में:**

| सेटिंग         | मान                            |
| -------------- | ------------------------------ |
| मॉडल           | runwayml/stable-diffusion-v1-5 |
| नेटवर्क रैंक   | 32-128                         |
| नेटवर्क अल्फ़ा | 16-64                          |
| लर्निंग रेट    | 1e-4                           |
| बैच साइज       | 1-4                            |
| एपॉक्स         | 10-20                          |
| ऑप्टिमाइज़र    | AdamW8bit                      |

### कमांड लाइन प्रशिक्षण

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

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

## Dreambooth प्रशिक्षण

### विषय प्रशिक्षण

```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="sks व्यक्ति की एक तस्वीर" \
    --class_prompt="एक व्यक्ति की तस्वीर" \
    --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
```

### शैली प्रशिक्षण

```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="xyz की शैली में चित्रकला" \
    --resolution=512 \
    --train_batch_size=1 \
    --learning_rate=5e-6 \
    --max_train_steps=2000 \
    --mixed_precision=fp16
```

## ट्रेनिंग टिप्स

### इष्टतम सेटिंग्स

| पैरामीटर       | व्यक्ति/चरित्र | शैली  | वस्तु |
| -------------- | -------------- | ----- | ----- |
| नेटवर्क रैंक   | 64-128         | 32-64 | 32    |
| नेटवर्क अल्फ़ा | 32-64          | 16-32 | 16    |
| लर्निंग रेट    | 1e-4           | 5e-5  | 1e-4  |
| एपॉक्स         | 15-25          | 10-15 | 10-15 |

### ओवरफिटिंग से बचना

* रेगुलराइज़ेशन इमेजों का उपयोग करें
* कम लर्निंग रेट
* कम एपोक्स
* नेटवर्क अल्फ़ा बढ़ाएँ

### अंडरफिटिंग से बचना

* अधिक प्रशिक्षण इमेजें
* अधिक लर्निंग रेट
* अधिक एपोक्स
* कम नेटवर्क अल्फ़ा

## प्रशिक्षण की निगरानी

### TensorBoard

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

### मुख्य मेट्रिक्स

* **loss** - इसे घटना चाहिए, फिर स्थिर होना चाहिए
* **lr** - लर्निंग रेट शेड्यूल
* **epoch** - प्रशिक्षण प्रगति

## अपने LoRA का परीक्षण

### Automatic1111 के साथ

LoRA को यहाँ कॉपी करें:

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

प्रॉम्प्ट में उपयोग करें:

```
<lora:my_lora:0.8> sks व्यक्ति की एक तस्वीर
```

### ComfyUI के साथ

LoRA नोड लोड करें और मॉडल से कनेक्ट करें।

### 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("sks व्यक्ति की एक तस्वीर, पेशेवर पोर्ट्रेट").images[0]
```

## उन्नत प्रशिक्षण

### LyCORIS (LoHa, LoKR)

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

### Textual Inversion

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

## सहेजना और निर्यात करना

### प्रशिक्षित मॉडल डाउनलोड करें

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

### फ़ॉर्मेट बदलें

```python

# SafeTensors से PyTorch
from safetensors.torch import load_file, save_file
import torch

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

## लागत का अनुमान

CLORE.AI मार्केटप्लेस की सामान्य दरें (2024 तक):

| GPU       | प्रति घंटा दर | प्रति दिन दर | 4-घंटे का सत्र |
| --------- | ------------- | ------------ | -------------- |
| 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        |

*मूल्य प्रदाता और मांग के अनुसार बदलते हैं। देखें* [*CLORE.AI मार्केटप्लेस*](https://clore.ai/marketplace) *वर्तमान दरों के लिए।*

**पैसे बचाएँ:**

* का उपयोग करें **स्पॉट** बाधित किए जा सकने वाले कार्य के लिए मार्केट — लगभग एक-तिहाई सर्वरों की स्पॉट कीमत ऑन-डिमांड से कम होती है (मध्य \~13% छूट), बाकी उससे मेल खाते हैं
* से भुगतान करें **CLORE** टोकन
* विभिन्न प्रदाताओं के बीच कीमतों की तुलना करें

## FLUX LoRA प्रशिक्षण

FLUX.1-dev और FLUX.1-schnell के लिए LoRA अडैप्टर ट्रेन करें — बेहतर गुणवत्ता वाले डिफ्यूज़न ट्रांसफ़ॉर्मर मॉडलों की नवीनतम पीढ़ी।

### VRAM आवश्यकताएँ

| मॉडल              | न्यूनतम VRAM | अनुशंसित GPU    |
| ----------------- | ------------ | --------------- |
| FLUX.1-schnell    | 16GB         | RTX 4080 / 3090 |
| FLUX.1-dev        | 24GB         | RTX 4090        |
| FLUX.1-dev (bf16) | 40GB+        | A100 40GB       |

> **ध्यान दें:** FLUX DiT (Diffusion Transformer) आर्किटेक्चर का उपयोग करता है — प्रशिक्षण की गतिशीलता SD 1.5 / SDXL से काफ़ी अलग होती है।

### FLUX के लिए इंस्टॉलेशन

CUDA 12.8 समर्थन के साथ PyTorch इंस्टॉल करें:

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

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

# FLUX-विशिष्ट: bf16 का उपयोग करें (fp16 नहीं — FLUX को 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

# FLUX LoRA पैरामीटर — SDXL से कम LR उपयोग करें!
learning_rate = 1e-4
lr_scheduler = "cosine_with_restarts"
lr_warmup_steps = 100

# नेटवर्क कॉन्फ़िगरेशन
network_module = "networks.lora_flux"
network_dim = 16           # FLUX: छोटा dim अच्छी तरह काम करता है (16-64)
network_alpha = 16         # network_dim के बराबर सेट करें

# FLUX-विशिष्ट विकल्प
t5xxl_max_token_length = 512
apply_t5_attn_mask = true

# ऑप्टिमाइज़र — Adafactor FLUX के लिए अच्छी तरह काम करता है
optimizer_type = "adafactor"
optimizer_args = ["scale_parameter=False", "relative_step=False", "warmup_init=False"]

# मेमोरी बचत
cache_latents = true
cache_latents_to_disk = true
cache_text_encoder_outputs = true
cache_text_encoder_outputs_to_disk = true

# प्रशिक्षण के दौरान सैंपलिंग (वैकल्पिक पूर्वावलोकन)
sample_every_n_epochs = 5
sample_prompts = "/workspace/sample_prompts.txt"
```

### FLUX LoRA प्रशिक्षण कमांड

```bash
# एकल GPU
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

# स्पष्ट पैरामीटर के साथ (कोई 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 बनाम SDXL: मुख्य अंतर

| पैरामीटर        | SDXL          | FLUX.1              |
| --------------- | ------------- | ------------------- |
| लर्निंग रेट     | 1e-3 से 1e-4  | **1e-4 से 5e-5**    |
| परिशुद्धता      | fp16 या bf16  | **bf16 आवश्यक**     |
| नेटवर्क मॉड्यूल | networks.lora | networks.lora\_flux |
| नेटवर्क डिम     | 32–128        | 8–64 (छोटा)         |
| ऑप्टिमाइज़र     | AdamW8bit     | Adafactor           |
| न्यूनतम VRAM    | 12GB          | 16–24GB             |
| आर्किटेक्चर     | U-Net         | DiT (ट्रांसफ़ॉर्मर) |

### FLUX के लिए लर्निंग रेट गाइड

```toml
# सतर्क (ज़्यादा सुरक्षित, ओवरफिटिंग की कम संभावना)
learning_rate = 5e-5

# मानक (अच्छा शुरुआती बिंदु)
learning_rate = 1e-4

# आक्रामक (अधिक अभिव्यक्तिशील, आर्टिफ़ैक्ट्स का जोखिम)
learning_rate = 2e-4
```

> **सुझाव:** FLUX, SDXL की तुलना में लर्निंग रेट के प्रति अधिक संवेदनशील है। शुरू करें `1e-4` और घटाकर `5e-5` अगर आपको गुणवत्ता संबंधी समस्याएँ दिखें। SDXL के लिए, `1e-3` आम है — FLUX के लिए इससे बचें।

### 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")

# अपने प्रशिक्षित LoRA को लोड करें
pipe.load_lora_weights("/workspace/output/my_flux_lora.safetensors")

image = pipe(
    prompt="sks व्यक्ति की एक तस्वीर, पेशेवर पोर्ट्रेट, स्टूडियो लाइटिंग",
    num_inference_steps=28,
    guidance_scale=3.5,
    width=1024,
    height=1024,
).images[0]

image.save("flux_lora_test.png")
```

***

## समस्या निवारण

### OOM त्रुटि

* बैच साइज़ को 1 करें
* gradient checkpointing सक्षम करें
* 8bit ऑप्टिमाइज़र का उपयोग करें
* रिज़ॉल्यूशन कम करें

### खराब परिणाम

* अधिक/बेहतर प्रशिक्षण इमेजें
* लर्निंग रेट समायोजित करें
* जाँचें कि कैप्शन इमेजों से मेल खाते हैं
* अलग नेटवर्क रैंक आज़माएँ

### प्रशिक्षण क्रैश होता है

* CUDA संस्करण जाँचें
* xformers अपडेट करें
* बैच आकार कम करें
* डिस्क स्थान जांचें

### FLUX-विशिष्ट समस्याएँ

* **"bf16 समर्थित नहीं है"** — A-सीरीज़ (Ampere+) या RTX 30/40 सीरीज़ GPU का उपयोग करें
* **FLUX.1-dev पर OOM** — FLUX.1-schnell (16GB चाहिए) पर स्विच करें या सक्षम करें `cache_text_encoder_outputs`
* **धुंधले परिणाम** — बढ़ाएँ `network_dim` 32–64 तक, learning rate को कम करके `5e-5`
* **NaN loss** — अक्षम करें `full_bf16`, अपने डेटासेट में भ्रष्ट छवियों की जांच करें


---

# 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-hi/training/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.