किराये के GPU पर $10 से कम में Stable Diffusion LoRA training

SDXL या किसी छोटे Flux मॉडल का LoRA किराये के GPU पर $10 से काफ़ी कम में train हो जाता है। सितंबर 2026 में RTX 4090 का किराया Vast.ai पर लगभग $0.31 प्रति घंटा और RunPod पर $0.74 प्रति घंटा है, और setup व testing मिलाकर एक SDXL LoRA session घंटे भर से थोड़ा ज़्यादा लेता है। यानी हर कोशिश $0.34 से $0.80 की, और $10 में दर्जन भर कोशिशें।

मुश्किल पैसा नहीं है। मुश्किल हैं तस्वीरें, captions और यह जानना कि कब रुकना है। यह guide इन सबको कवर करती है, ऐसी commands के साथ जिन्हें आप सीधे paste कर सकते हैं। कीमतें और टूल के वर्ज़न सितंबर 2026 में जाँचे गए; स्रोत आख़िर में हैं।

पाँच चरणों में पूरा काम

LoRA क्या है और सस्ता क्यों है

LoRA (Low-Rank Adaptation) base मॉडल को जस का तस रखता है और उसकी कुछ layers के बगल में दो छोटे matrices train करता है। मूल paper के मुताबिक़ GPT-3 175B की पूरी fine-tuning के मुक़ाबले trainable parameters 10,000 गुना और GPU मेमोरी 3 गुना कम हो गई। image मॉडल में भी यही होता है: SDXL का base checkpoint 6.9 GB की फ़ाइल है, जबकि आपका train किया LoRA एक छोटी अलग फ़ाइल है, जिसे आप उसके ऊपर मनचाही strength पर load करते हैं।

इसीलिए एक consumer GPU काफ़ी है, और एक run दिनों नहीं, दसियों मिनट लेता है।

VRAM के हिसाब से GPU चुनें

आप क्या train कर सकते हैं, यह VRAM तय करती है। run में कितने billed मिनट लगेंगे, यह speed तय करती है, इसलिए प्रति घंटा महँगा पर तेज़ कार्ड प्रति run लगभग उतने का ही पड़ सकता है।

मॉडल family	docs में न्यूनतम	आराम से	टिप्पणी
SD 1.5	8 GB	12 GB+	512x512 पर train, सबसे सस्ता और तेज़
SDXL	8 GB (10 GB की सलाह)	24 GB	सिर्फ़ U-Net, latents और text encoder outputs cache
FLUX.1 [dev] (12B)	भारी block swapping के साथ 8 GB	24 GB	sd-scripts 24, 16, 12, 10 और 8 GB की settings देता है
FLUX.2 [klein] 4B/9B	बताया नहीं गया	24 GB	BFL: लगभग 13 GB bf16 weights, LoRA run 24 GB से कम में

कम VRAM वाली settings काम करती हैं, पर धीमी हैं। sd-scripts FLUX.1 को 8 से 16 GB में transformer blocks को GPU और system RAM के बीच swap करके फ़िट करता है, और हर swap में वह समय लगता है जिसका आप पैसा देते हैं। किराये की मशीन पर 24 GB कार्ड समझदारी वाला default है: RTX 3090 या 4090। RTX 5090 (32 GB) भी चलता है, लेकिन sd-scripts बताता है कि उसके लिए CUDA 12.8 या 12.9 के साथ PyTorch 2.8.0 चाहिए, इसलिए देख लें कि आपके template में इतना नया stack है।

datacenter कार्ड तेज़ हैं, लेकिन RunPod A100 80 GB $1.59 प्रति घंटा में देता है, जो 4090 के दोगुने से ज़्यादा है। 20 या 30 तस्वीरों के LoRA के लिए अतिरिक्त speed शायद ही यह फ़र्क़ पूरा करती है; ये बड़े datasets या पूरी fine-tuning के लिए ज़्यादा ठीक हैं।

कहाँ किराये पर लें, और ख़र्च कितना

आपको ऐसा प्लेटफ़ॉर्म चाहिए जो मशीन दे: shell या Jupyter notebook, डिस्क, और फ़ाइलें अंदर-बाहर कॉपी करने का तरीका। इस तरह के काम के लिए Vast.ai और RunPod सबसे आम विकल्प हैं।

GPU	VRAM	Vast.ai (से शुरू)	RunPod pricing पेज	RunPod का सबसे सस्ता दर्ज
RTX 3090	24 GB	लगभग $0.11–0.13/घंटा	$0.50/घंटा	$0.22/घंटा
RTX 4090	24 GB	लगभग $0.31–0.33/घंटा	$0.74/घंटा	$0.34/घंटा
RTX 5090	32 GB	लगभग $0.41–0.47/घंटा	$0.99/घंटा	$0.69/घंटा

कीमतें सितंबर 2026 की हैं। “Vast.ai (से शुरू)” और “RunPod का सबसे सस्ता दर्ज” getdeploying.com के price tracker से हैं; बीच वाला कॉलम RunPod का अपना pricing पेज है। Vast.ai पर host अपनी कीमत ख़ुद तय करते हैं, इसलिए आपको दिखने वाले offers जगह और reliability score के हिसाब से अलग होंगे।

दोनों प्रति सेकंड बिल करते हैं। अतिरिक्त शुल्क अलग हैं, और एक घंटे के काम में ये प्रति घंटा दर से जितना लगता है उससे ज़्यादा मायने रखते हैं:

• Vast.ai storage का पैसा “जब तक आपका instance मौजूद है, चाहे वह चल रहा हो या नहीं” लेता है, और bandwidth का पैसा प्रति byte, हर host की तय दर पर। महँगी bandwidth वाले host पर 7 GB का base मॉडल डाउनलोड करना जुड़ता जाता है। instance को सिर्फ़ रोकें नहीं, delete करें।
• RunPod चालू रहते container disk का $0.10 प्रति GB प्रति माह लेता है, रुकने के बाद उसका कुछ नहीं, और रुकी हुई volume disk का $0.20 प्रति GB प्रति माह। अंदर या बाहर जाने वाले डेटा का वह पैसा नहीं लेता।

दोनों पर तैयार templates हैं। ai-toolkit का author एक official RunPod template रखता है, और kohya_ss का README RunPod को supported setup बताता है। template से billed समय पर PyTorch इंस्टॉल करने के दस या ज़्यादा मिनट बचते हैं। कीमतों की बड़ी तुलना के लिए GPUFlow vs Vast.ai vs RunPod vs SaladCloud और GPU किराये की छिपी लागत देखें।

dataset और captions तैयार करें

यह सब कुछ भी किराये पर लेने से पहले अपने कंप्यूटर पर करें।

तस्वीरें

• गिनती। एक इंसान, चीज़ या style के लिए 15 से 40 तस्वीरें। Black Forest Labs FLUX.2 [klein] के लिए “एक जैसे look वाली 15–40 तस्वीरें” सुझाता है। अगर अतिरिक्त तस्वीरें कमज़ोर हैं, तो ज़्यादा बेहतर नहीं है।
• एकरूपता और विविधता। हर तस्वीर में concept दिखना चाहिए। बाक़ी सब बदलना चाहिए: angle, रोशनी, background, framing। अगर आपके product की हर फ़ोटो एक ही सफ़ेद मेज़ पर है, तो LoRA मेज़ सीख लेगा।
• quality। साफ़, ठीक exposure, कोई watermark या ऊपर लिखा टेक्स्ट नहीं। LoRA noise और JPEG blocks को भी उतनी ही वफ़ादारी से सीखता है जितना बाक़ी सब।
• resolution। SDXL और Flux के लिए छोटी side पर कम से कम 1024 pixels, SD 1.5 के लिए 512। वर्गाकार crop की ज़रूरत नहीं: bucketing चालू हो तो sd-scripts तस्वीरों को aspect ratio के हिसाब से समूहों में बाँटता है।

Captions

हर तस्वीर के साथ उसी नाम की एक text फ़ाइल होती है (photo01.jpg, photo01.txt)। caption मॉडल को बताता है कि कौन-सी बात शब्दों से पहले ही समझाई जा चुकी है, ताकि LoRA वह सीखे जो नहीं समझाई गई। सबसे पहले एक दुर्लभ trigger word रखें, फिर वह सब लिखें जिसे आप बदलने लायक़ रखना चाहते हैं:

zxq_mug, a ceramic coffee mug on a wooden desk, morning light from the left, shallow depth of field

दो टूल आपके लिए पहला draft लिख देंगे:

• WD14 tagger, जो sd-scripts में शामिल है, comma से अलग tags बनाता है। anime-style मॉडल और tags पर train हुए SDXL fine-tunes के लिए अच्छा है:

  python finetune/tag_images_by_wd14_tagger.py --onnx \
    --repo_id SmilingWolf/wd-swinv2-tagger-v3 --batch_size 4 /workspace/dataset/img

• JoyCaption, diffusion मॉडल की training के लिए बना एक open (Apache 2.0) captioning मॉडल, सामान्य भाषा में वाक्य लिखता है, जो Flux के लिए tags से बेहतर हैं। उसका README कहता है कि bf16 में उसे लगभग 17 GB VRAM चाहिए, और छोटे कार्ड के लिए 8-bit और 4-bit वर्ज़न हैं।

OneTrainer में भी BLIP, BLIP2 और WD-1.4 के साथ built-in captioning है। draft कोई भी लिखे, हर caption पढ़ें और सुधारें। पूरे project का सबसे क़ीमती आधा घंटा यही है।

trainer चुनें

चार टूल लगभग सबकी ज़रूरत पूरी करते हैं। सभी मुफ़्त और open source हैं।

टूल	Interface	मॉडल (सितंबर 2026)	किसके लिए ठीक
kohya-ss/sd-scripts	Command line	SD 1.x/2.x, SDXL, SD3/3.5, FLUX.1, Lumina, HunyuanImage-2.1, Anima	दोहराए जा सकने वाले runs, पूरा नियंत्रण
bmaltais/kohya_ss	sd-scripts के ऊपर web UI	sd-scripts जैसे ही	flags याद किए बिना sd-scripts
Nerogar/OneTrainer	Desktop UI और CLI	SD 1.5 से 3.5, SDXL, FLUX.1, FLUX.2, Chroma, Qwen Image और अन्य	built-in captioning और masking
ostris/ai-toolkit	Web UI और YAML configs	SD 1.5, SDXL, FLUX.1, FLUX.2, Qwen-Image, Wan video और अन्य	Flux और नए मॉडल, RunPod template

sd-scripts वर्ज़न 0.11.1 (जून 2026) पर है, Python 3.10 के साथ टेस्ट हुआ है और उसे PyTorch 2.6.0 या नया चाहिए। ai-toolkit Python 3.12 की सलाह देता है और फ़िलहाल CUDA 13.0 के लिए बना PyTorch 2.13.0 इंस्टॉल करता है। OneTrainer को Python 3.10 से 3.13 चाहिए।

मैं SDXL के लिए sd-scripts इस्तेमाल करता हूँ, क्योंकि command line ही पूरा configuration है, जिससे runs दोहराना और उनकी तुलना करना आसान होता है, और Flux के लिए ai-toolkit।

sd-scripts से SDXL LoRA train करें

NVIDIA driver वाले नए Linux instance पर setup कुछ commands का है:

git clone https://github.com/kohya-ss/sd-scripts.git
cd sd-scripts
python -m venv venv && source venv/bin/activate
pip install torch==2.6.0 torchvision==0.21.0 --index-url https://download.pytorch.org/whl/cu124
pip install --upgrade -r requirements.txt
accelerate config default --mixed_precision bf16

# SDXL base model (not gated, CreativeML Open RAIL++-M license)
hf download stabilityai/stable-diffusion-xl-base-1.0 sd_xl_base_1.0.safetensors \
  --local-dir /workspace/models

तस्वीरों और .txt captions वाला अपना फ़ोल्डर scp, rsync या प्लेटफ़ॉर्म के file browser से /workspace/dataset/img में कॉपी करें। फिर /workspace/dataset.toml में dataset का ब्योरा लिखें:

[general]
caption_extension = ".txt"
enable_bucket = true

[[datasets]]
resolution = 1024
batch_size = 1

  [[datasets.subsets]]
  image_dir = "/workspace/dataset/img"
  num_repeats = 10

और training शुरू करें:

accelerate launch --num_cpu_threads_per_process 1 sdxl_train_network.py \
  --pretrained_model_name_or_path=/workspace/models/sd_xl_base_1.0.safetensors \
  --dataset_config=/workspace/dataset.toml \
  --output_dir=/workspace/output --output_name=zxq_mug \
  --save_model_as=safetensors \
  --network_module=networks.lora --network_dim=16 --network_alpha=8 \
  --network_train_unet_only \
  --optimizer_type=AdamW8bit --learning_rate=1e-4 \
  --lr_scheduler=constant_with_warmup --lr_warmup_steps=100 \
  --max_train_epochs=8 --save_every_n_epochs=2 \
  --mixed_precision=bf16 --save_precision=bf16 \
  --cache_latents --cache_latents_to_disk --cache_text_encoder_outputs \
  --gradient_checkpointing --sdpa --seed=42 \
  --sample_prompts=/workspace/prompts.txt --sample_every_n_epochs=2

prompts.txt में हर लाइन पर एक test prompt होता है, size, seed और steps के लिए sd-scripts के inline options के साथ:

zxq_mug, a ceramic coffee mug on a kitchen counter --w 1024 --h 1024 --d 42 --s 28
zxq_mug, a ceramic coffee mug held by a hiker on a mountain top --w 1024 --h 1024 --d 42 --s 28

settings क्या करती हैं

• Steps। तस्वीरें × repeats × epochs ÷ batch size। 25 तस्वीरों के साथ: 25 × 10 × 8 = 2,000 steps।
• network_dim 16, network_alpha 8। LoRA की क्षमता। एक चीज़ या चेहरे के लिए 16 काफ़ी है; style के लिए कभी-कभी 32 चाहिए। ऊँची rank जल्दी overfit होती है और फ़ाइल बड़ी बनाती है।
• --network_train_unet_only। यहाँ ज़रूरी है: text encoders को train करते हुए sd-scripts उनके outputs cache करने से मना कर देता है, और उसके docs वैसे भी SDXL LoRAs के लिए सिर्फ़ U-Net training को “highly recommended” बताते हैं।
• caching और gradient checkpointing। यही SDXL को 8 से 10 GB में फ़िट करते हैं। caching से caption shuffling और caption dropout भी बंद हो जाते हैं, इसीलिए वे dataset फ़ाइल में नहीं हैं।
• AdamW8bit के साथ learning_rate 1e-4। sd-scripts के अपने SDXL LoRA उदाहरण का मान। अगर चार epochs के बाद samples मुश्किल से बदलें, तो 2e-4 आज़माएँ। अगर वे आपकी training तस्वीरों की नक़ल बनने लगें, तो इसे घटाएँ या पहले रुकें।
• हर 2 epochs पर checkpoint। आपको epochs 2, 4, 6 और 8 की फ़ाइलें मिलेंगी, और आप सबसे अच्छी चुनेंगे। सबसे अच्छा LoRA अक्सर आख़िरी नहीं होता।

कितना समय लगता है

kohya_ss के एक issue thread में यूज़र्स ने RTX 4090 पर gradient checkpointing के साथ, 1024x1024 और batch size 1 पर SDXL LoRA training के लिए लगभग 1.1 से 1.4 iterations प्रति सेकंड बताए। इस speed पर 2,000 steps में 24 से 30 मिनट लगते हैं, और latents cache करने के कुछ मिनट अलग। वही thread यह भी दिखाता है कि जब कार्ड की VRAM ख़त्म होकर shared memory में चली जाती है तो हालत कितनी बिगड़ती है: हर step में 50 सेकंड या ज़्यादा। अगर आपकी speed अपेक्षित range से बहुत नीचे है, तो settings को दोष देने से पहले nvidia-smi देखें।

ai-toolkit से Flux और नए मॉडल

Flux के लिए ai-toolkit सबसे आसान रास्ता है। किराये की मशीन पर:

git clone https://github.com/ostris/ai-toolkit.git
cd ai-toolkit
python3 -m venv venv && source venv/bin/activate
pip3 install --no-cache-dir torch==2.13.0 torchvision==0.28.0 torchaudio==2.11.0 \
  --index-url https://download.pytorch.org/whl/cu130
pip3 install -r requirements.txt
cp config/examples/train_lora_flux_24gb.yaml config/zxq_mug.yml
# edit the dataset path, trigger word and steps, then:
python run.py config/zxq_mug.yml

या cd ui && npm run build_and_start से web UI चलाएँ और port 8675 खोलें। अगर server तक दूसरे लोग पहुँच सकते हैं, तो README की सलाह के मुताबिक़ पहले AI_TOOLKIT_AUTH में password सेट करें।

Flux मॉडल चुनने से पहले licenses के बारे में दो बातें जान लें:

• FLUX.1 [dev] Hugging Face पर gated है। आप FLUX.1 [dev] Non-Commercial License स्वीकार करते हैं और उसे डाउनलोड करने के लिए Hugging Face read token इस्तेमाल करते हैं। उसका model card कहता है कि बनाए गए outputs commercial काम में इस्तेमाल हो सकते हैं; weights और आपका LoRA non-commercial license के तहत आते हैं।
• FLUX.2 [klein] 4B Apache 2.0 है और gated नहीं है। 9B वर्ज़न FLUX Non-Commercial License पर है।

Black Forest Labs ने जून 2026 में ai-toolkit से FLUX.2 [klein] LoRAs train करने की guide प्रकाशित की: RTX 4090 पर 1,800 steps का run “एक घंटे से कम लेता है”, और वे लगभग 750 से 1,500 steps के checkpoints देखने की सलाह देते हैं। FLUX.1 [dev] के लिए, जो klein 4B से तीन गुना बड़ा है, मुझे इतना ठोस प्रकाशित समय नहीं मिला; ज़्यादा समय का बजट रखें और पहला run ख़ुद मापें।

पैसा देना बंद करने से पहले LoRA टेस्ट करें

मशीन चालू रहते ही हर सेव हुए epoch की sample तस्वीरें देखें। ये आपको मुफ़्त में बताती हैं कि LoRA ने concept सीखा या नहीं, और overfit होना कब शुरू हुआ। फिर पसंद के checkpoints डाउनलोड करें:

rsync -avP user@your-instance:/workspace/output/*.safetensors ./loras/

घर पर फ़ाइल को ComfyUI के models/loras फ़ोल्डर या Forge के models/Lora में रखें, और तय seeds के साथ टेस्ट करें:

• Strength। 0.6, 0.8 और 1.0 आज़माएँ। कुछ LoRA 1.0 से नीचे सबसे अच्छे दिखते हैं।
• लचीलापन। trigger को ऐसे दृश्यों में रखें जो आपके डेटा में नहीं थे। पहाड़ पर mug, painting में चेहरा। अगर यह सिर्फ़ training तस्वीरों जैसे दृश्यों में काम करता है, तो overfit है: पहले का epoch लें या repeats घटाएँ।
• रिसाव। trigger word के बिना generate करें। अगर concept फिर भी दिख जाए, तो आपके captions ने तस्वीर का काफ़ी हिस्सा नहीं बताया।

नतीजा ग़लत हो तो इलाज आमतौर पर dataset में होता है: कुछ कमज़ोर तस्वीरें हटाना, या ऐसे captions जो उन चीज़ों का नाम लें जिन्हें आप बदलने लायक़ रखना चाहते हैं। learning rate बदलना दूसरा क़दम है, पहला नहीं।

ख़र्च का पूरा हिसाब

एक SDXL LoRA, 25 तस्वीरें, 2,000 steps, RTX 4090 पर:

चरण	समय
template से शुरू करना, sd-scripts इंस्टॉल करना	10 मिनट
SDXL base डाउनलोड, dataset अपलोड, cache	10 मिनट
Training (1.1 से 1.4 it/s पर 2,000 steps)	30 मिनट
samples देखना, checkpoints डाउनलोड करना, instance delete करना	15 मिनट
कुल	65 मिनट (1.08 घंटे)

• Vast.ai पर $0.31/घंटा: 1.08 × $0.31 = $0.34, साथ में storage और host की bandwidth दर।
• RunPod पर $0.74/घंटा: 1.08 × $0.74 = $0.80। उस घंटे के लिए 50 GB container disk जोड़ती है 50 × $0.10 ÷ 730 घंटे = 1 cent से कम।

एक घंटे की training और 30 मिनट के setup व testing वाला FLUX.2 [klein] LoRA RunPod पर 1.5 × $0.74 = $1.11 का पड़ता है, या Vast.ai पर 1.5 × $0.31 = $0.47 का।

$10 का बजट असल में training से शायद ही बिगड़ता है। बिगाड़ता है रात भर चालू छूटा instance (12 घंटे × $0.74 = $8.88), storage का पैसा देता रुका हुआ Vast.ai instance, या billed समय पर तस्वीरों के captions लिखने में लगा एक घंटा। प्रति सेकंड बिलिंग तभी फ़ायदा देती है जब काम ख़त्म होते ही आप मशीन delete कर दें।

GPUFlow कहाँ फ़िट होता है

इस काम में नहीं होता। GPUFlow एक language मॉडल तक पहुँच किराये पर देता है, जिसे provider अपने GPU पर (आमतौर पर Ollama से) चलाता है, एक OpenAI-compatible API key के ज़रिए। वहाँ न shell है, न SSH, न फ़ाइल access, इसलिए आप trainer इंस्टॉल नहीं कर सकते, तस्वीरें अपलोड नहीं कर सकते और LoRA डाउनलोड नहीं कर सकते। वह chat मॉडल चलाता है, image मॉडल नहीं। training Vast.ai, RunPod या ऐसे किसी प्लेटफ़ॉर्म पर करें जो आपको मशीन किराये पर दे।

अगर आप तस्वीरों की जगह टेक्स्ट पर काम कर रहे हैं, तो किराये पर लो, train करो, delete करो वाला यही तरीका language मॉडल पर भी लागू होता है: किराये के GPU पर LLM की निजी fine-tuning देखें।

स्रोत

सभी की जाँच सितंबर 2026 में की गई।

• LoRA paper: Hu et al., LoRA: Low-Rank Adaptation of Large Language Models
• sd-scripts: README और releases, SDXL LoRA training, SDXL notes और VRAM, dataset config, FLUX.1 LoRA training, WD14 tagger
• bmaltais/kohya_ss, Nerogar/OneTrainer, ostris/ai-toolkit, JoyCaption
• SDXL पर 4090 की speed: kohya_ss issue #1288
• Black Forest Labs: FLUX.2 [klein] को 60 मिनट से कम में LoRA से fine-tune करें, model cards: FLUX.1 [dev], FLUX.2 [klein] 4B, FLUX.2 [klein] 9B
• Stable Diffusion XL base 1.0 model card
• कीमतें: RunPod pricing, RunPod pod pricing और storage, Vast.ai pricing, getdeploying.com पर RTX 3090, RTX 4090, RTX 5090 और Vast.ai
• GPUFlow: API quickstart