Kohya प्रशिक्षण

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

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

सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं जिन्हें द्वारा किराए पर लिया गया है CLORE.AI मार्केटप्लेस.

CLORE.AI पर किराये पर लेना

पर जाएँ CLORE.AI मार्केटप्लेस
GPU प्रकार, VRAM, और मूल्य के अनुसार फ़िल्टर करें
चुनें ऑन-डिमांड (निश्चित दर) या स्पॉट (बिड प्राइस)
अपना ऑर्डर कॉन्फ़िगर करें:
- Docker इमेज चुनें
- पोर्ट सेट करें (SSH के लिए TCP, वेब UI के लिए HTTP)
- यदि आवश्यक हो तो एनवायरनमेंट वेरिएबल जोड़ें
- स्टार्टअप कमांड दर्ज करें
भुगतान चुनें: CLORE, BTC, या USDT/USDC
ऑर्डर बनाएं और डिप्लॉयमेंट का इंतज़ार करें

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

कनेक्शन विवरण में खोजें मेरे ऑर्डर
वेब इंटरफेस: 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.5.1-cuda12.4-cudnn9-devel

पोर्ट:

22/tcp
7860/http

कमांड:

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 में मेरे ऑर्डर:

जाएँ मेरे ऑर्डर पृष्ठ
अपने ऑर्डर पर क्लिक करें
खोजें http_pub URL (उदा., abc123.clorecloud.net)

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

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

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

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

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

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

a photo of sks person, professional portrait, studio lighting, high quality

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

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

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

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

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)

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 प्रशिक्षण

सब्जेक्ट प्रशिक्षण

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

स्टाइल प्रशिक्षण

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

प्रशिक्षण सुझाव

उत्तम सेटिंग्स

पैरामीटर

व्यक्ति/चरित्र

शैली

वस्तु

नेटवर्क रैंक

64-128

32-64

नेटवर्क अल्फा

32-64

16-32

लर्निंग रेट

1e-4

5e-5

1e-4

एपॉच

15-25

10-15

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

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

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

अधिक प्रशिक्षण छवियाँ
ऊँची लर्निंग दर
अधिक एपॉक्स
नेटवर्क अल्फा कम करें

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

TensorBoard

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

प्रमुख मेट्रिक्स

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

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

Automatic1111 के साथ

LoRA कॉपी करें:

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

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

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

ComfyUI के साथ

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

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]

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

LyCORIS (LoHa, LoKR)

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

Textual Inversion

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

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

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

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

फॉर्मैट बदलना


# 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 मार्केटप्लेस वर्तमान दरों के लिए।

पैसे बचाएँ:

उपयोग करें स्पॉट लचीले वर्कलोड के लिए मार्केट (अक्सर 30-50% सस्ता)
भुगतान करें 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.4 समर्थन के साथ PyTorch इंस्टॉल करें:

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

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"

# 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         # नेटवर्क_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 प्रशिक्षण कमांड

# एकल 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 (Transformer)

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

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

# मानक (शुरू करने के लिए अच्छा बिंदु)
learning_rate = 1e-4

# आक्रामक (अधिक अभिव्यक्तिपूर्ण, आर्टिफैक्ट्स का जोखिम)
learning_rate = 2e-4

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

FLUX LoRA का परीक्षण करना

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

समस्याओं का निवारण

OOM त्रुटि

बैच साइज को 1 तक घटाएँ
ग्रेडियेंट चेकपॉइंटिंग सक्षम करें
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 तक, लर्निंग रेट को घटाएँ 5e-5
NaN लॉस — अक्षम करें full_bf16और अपने डेटासेट में भ्रष्ट छवियों की जाँच करें

PreviousDreamBooth NextLLM को फाइन-ट्यून करें

Last updated 1 day ago

Was this helpful?

hashtagCLORE.AI पर किराये पर लेना

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

hashtagKohya क्या है?

hashtagआवश्यकताएँ

hashtagत्वरित तैनाती

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

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

hashtagडेटासेट की तैयारी

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

hashtagछवि आवश्यकताएँ

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

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

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

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

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

hashtagLoRA प्रशिक्षण (SDXL)

hashtagDreambooth प्रशिक्षण

hashtagसब्जेक्ट प्रशिक्षण

hashtagस्टाइल प्रशिक्षण

hashtagप्रशिक्षण सुझाव

hashtagउत्तम सेटिंग्स

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

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

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

hashtagTensorBoard

hashtagप्रमुख मेट्रिक्स

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

hashtagAutomatic1111 के साथ

hashtagComfyUI के साथ

hashtagDiffusers के साथ

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

hashtagLyCORIS (LoHa, LoKR)

hashtagTextual Inversion

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

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

hashtagफॉर्मैट बदलना

hashtagलागत अनुमान

hashtagFLUX LoRA प्रशिक्षण

hashtagVRAM आवश्यकताएँ

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

hashtagFLUX LoRA कॉन्फ़िगरेशन (flux_lora.toml)

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

hashtagFLUX बनाम SDXL: प्रमुख अंतर

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

hashtagFLUX LoRA का परीक्षण करना

hashtagसमस्याओं का निवारण

hashtagOOM त्रुटि

hashtagखराब परिणाम

hashtagप्रशिक्षण क्रैश होते हैं

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

CLORE.AI पर किराये पर लेना

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

Kohya क्या है?

आवश्यकताएँ

त्वरित तैनाती

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

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

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

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

छवि आवश्यकताएँ

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

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

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

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

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

LoRA प्रशिक्षण (SDXL)

Dreambooth प्रशिक्षण

सब्जेक्ट प्रशिक्षण

स्टाइल प्रशिक्षण

प्रशिक्षण सुझाव

उत्तम सेटिंग्स

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

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

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

TensorBoard

प्रमुख मेट्रिक्स

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

Automatic1111 के साथ

ComfyUI के साथ

Diffusers के साथ

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

LyCORIS (LoHa, LoKR)

Textual Inversion

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

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

फॉर्मैट बदलना

लागत अनुमान

FLUX LoRA प्रशिक्षण

VRAM आवश्यकताएँ

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

FLUX LoRA कॉन्फ़िगरेशन (flux_lora.toml)

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

FLUX बनाम SDXL: प्रमुख अंतर

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

FLUX LoRA का परीक्षण करना

समस्याओं का निवारण

OOM त्रुटि

खराब परिणाम

प्रशिक्षण क्रैश होते हैं

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