Qwen Image क्विकस्टार्ट (v1.0 / v2.0)¶

यह गाइड पुराने 20B मॉडल के लिए है। स्पष्ट रूप से model_flavour: "v1.0" या "v2.0" सेट करें; वर्तमान डिफ़ॉल्ट 2.1 है। नए उदाहरण और सेटिंग के लिए Qwen Image 2.1 क्विकस्टार्ट देखें।

🆕 Edit checkpoints चाहिए? paired‑reference training निर्देशों के लिए Qwen Image Edit quickstart देखें।

इस उदाहरण में, हम Qwen Image के लिए LoRA प्रशिक्षण करेंगे, जो 20B पैरामीटर वाला vision‑language मॉडल है। इसके आकार के कारण हमें आक्रामक मेमोरी ऑप्टिमाइज़ेशन तकनीकों की आवश्यकता होगी।

24GB GPU पूर्ण न्यूनतम है, और फिर भी व्यापक quantization और सावधानीपूर्ण कॉन्फ़िगरेशन चाहिए। 40GB+ अधिक सहज अनुभव के लिए मज़बूती से अनुशंसित है।

24G पर training करते समय, validations कम resolution या int8 से आगे की aggressive quant level के बिना OOM होंगी।

हार्डवेयर आवश्यकताएँ¶

Qwen Image एक 20B पैरामीटर मॉडल है जिसमें एक परिष्कृत text encoder है जो अकेला ~16GB VRAM खपत करता है (quantization से पहले)। यह मॉडल 16 latent channels वाला custom VAE उपयोग करता है।

पूर्वापेक्षाएँ¶

Python 3.12–3.14 इस्तेमाल करें। Python और CUDA सेटअप के लिए इंस्टॉलेशन गाइड देखें।

इंस्टॉलेशन¶

pip के जरिए SimpleTuner इंस्टॉल करें:

pip install 'simpletuner[cuda]'

# CUDA 13 / Blackwell users (NVIDIA B-series GPUs)
pip install 'simpletuner[cuda13]' --extra-index-url https://download.pytorch.org/whl/cu130

मैनुअल इंस्टॉलेशन या डेवलपमेंट सेटअप के लिए, installation documentation देखें।

वातावरण सेटअप¶

SimpleTuner चलाने के लिए, आपको एक configuration फ़ाइल, dataset और model directories, तथा एक dataloader configuration फ़ाइल सेट करनी होगी।

Configuration file¶

एक प्रयोगात्मक स्क्रिप्ट, configure.py, इंटरैक्टिव step‑by‑step कॉन्फ़िगरेशन के जरिए इस सेक्शन को पूरी तरह स्किप करने में मदद कर सकती है। इसमें कुछ सुरक्षा फीचर्स हैं जो सामान्य pitfalls से बचाते हैं।

नोट: यह आपके dataloader को कॉन्फ़िगर नहीं करता। आपको उसे बाद में मैन्युअली करना होगा।

इसे चलाने के लिए:

simpletuner configure

⚠️ जिन देशों में Hugging Face Hub आसानी से उपलब्ध नहीं है, वहाँ HF_ENDPOINT=https://hf-mirror.com को अपने ~/.bashrc या ~/.zshrc में जोड़ें, यह आपके सिस्टम के $SHELL पर निर्भर करता है।

यदि आप मैन्युअल कॉन्फ़िगर करना पसंद करते हैं:

config/config.json.example को config/config.json में कॉपी करें:

cp config/config.json.example config/config.json

फिर, आपको संभवतः निम्न वेरिएबल्स बदलने होंगे:

• model_type - इसे lora पर सेट करें।
• lora_type - PEFT LoRA के लिए standard या LoKr के लिए lycoris सेट करें।
• model_family - इसे qwen_image पर सेट करें।
• model_flavour - इसे v1.0 पर सेट करें।
• output_dir - इसे उस डायरेक्टरी पर सेट करें जहाँ आप अपने checkpoints और validation images रखना चाहते हैं। यहाँ full path उपयोग करने की सलाह है।
• train_batch_size - इसे उपलब्ध VRAM के अनुसार सेट करें। SimpleTuner के मौजूदा Qwen overrides में batch size > 1 समर्थित है।
• gradient_accumulation_steps - यदि per-step VRAM बढ़ाए बिना effective batch बढ़ाना हो, तो इसे 2‑8 पर सेट करें।
• validation_resolution - मेमोरी सीमाओं के लिए 1024x1024 या उससे कम रखें।
• 24G अभी 1024x1024 validations संभाल नहीं सकता — आकार घटाएँ
• अन्य resolutions को कॉमा से अलग कर सकते हैं: 1024x1024,768x768,512x512
• validation_guidance - अच्छे परिणामों के लिए 3.0‑4.0 के आसपास रखें।
• validation_num_inference_steps - लगभग 30 रखें।

• use_ema - इसे true सेट करने से स्मूद परिणाम मिलते हैं लेकिन मेमोरी बढ़ती है।

• optimizer - अच्छे परिणामों के लिए optimi-lion, या यदि मेमोरी उपलब्ध हो तो adamw_bf16।

• mixed_precision - Qwen Image के लिए bf16 आवश्यक है।
• gradient_checkpointing - उचित मेमोरी उपयोग के लिए इसे अनिवार्य (true) रखें।
• base_model_precision - 24GB कार्ड्स के लिए int8-quanto या nf4-bnb मज़बूती से अनुशंसित है।
• quantize_via - छोटे GPUs पर quantization के दौरान OOM से बचने के लिए cpu सेट करें।
• quantize_activations - प्रशिक्षण गुणवत्ता बनाए रखने के लिए false रखें।

24GB GPUs के लिए memory optimization settings: - lora_rank - 8 या कम रखें। - lora_alpha - इसे lora_rank के बराबर रखें। - flow_schedule_shift - 1.73 पर सेट करें (या 1.0‑3.0 के बीच प्रयोग करें)।

न्यूनतम सेटअप के लिए आपका config.json कुछ ऐसा दिखेगा:

{
    "model_type": "lora",
    "model_family": "qwen_image",
    "model_flavour": "v1.0",
    "lora_type": "standard",
    "lora_rank": 8,
    "lora_alpha": 8,
    "output_dir": "output/models-qwen_image",
    "train_batch_size": 1,
    "gradient_accumulation_steps": 4,
    "validation_resolution": "512x512",
    "validation_guidance": 4.0,
    "validation_num_inference_steps": 30,
    "validation_seed": 42,
    "validation_prompt": "A photo-realistic image of a cat",
    "validation_step_interval": 100,
    "vae_batch_size": 1,
    "seed": 42,
    "resume_from_checkpoint": "latest",
    "resolution": 1024,
    "resolution_type": "pixel_area",
    "report_to": "tensorboard",
    "optimizer": "optimi-lion",
    "num_train_epochs": 0,
    "num_eval_images": 1,
    "mixed_precision": "bf16",
    "minimum_image_size": 0,
    "max_train_steps": 1000,
    "max_grad_norm": 0.01,
    "lr_warmup_steps": 100,
    "lr_scheduler": "constant_with_warmup",
    "learning_rate": "1e-4",
    "gradient_checkpointing": "true",
    "base_model_precision": "int2-quanto",
    "quantize_via": "cpu",
    "quantize_activations": false,
    "flow_schedule_shift": 1.73,
    "disable_benchmark": false,
    "data_backend_config": "config/qwen_image/multidatabackend.json",
    "checkpoints_total_limit": 5,
    "checkpoint_step_interval": 500,
    "caption_dropout_probability": 0.0,
    "aspect_bucket_rounding": 2
}

ℹ️ Multi‑GPU उपयोगकर्ता उपयोग किए जाने वाले GPU की संख्या कॉन्फ़िगर करने के लिए इस दस्तावेज़ को देखें।

⚠️ 24GB GPUs के लिए महत्वपूर्ण: text encoder अकेला ~16GB VRAM उपयोग करता है। int2-quanto या nf4-bnb quantization के साथ इसे काफी कम किया जा सकता है।

शामिल qwen_image/v2.1/default/peft-lora उदाहरण अब 2.1 प्रशिक्षित करता है। पुराने प्रकारों के लिए उस उदाहरण की जगह अपनी स्पष्ट config से simpletuner train चलाएँ।

उन्नत प्रयोगात्मक विशेषताएँ¶

{
  "nickname": "the prompt goes here",
  "another_nickname": "another prompt goes here"
}

  "user_prompt_library": "config/user_prompt_library.json",

{
    "anime_style": "a breathtaking anime-style portrait with vibrant colors and expressive features",
    "chef_cooking": "a high-quality, detailed photograph of a sous-chef immersed in culinary creation",
    "portrait": "a lifelike and intimate portrait showcasing unique personality and charm",
    "cinematic": "a cinematic, visually stunning photo with dramatic and captivating presence",
    "elegant": "an elegant and timeless portrait exuding grace and sophistication",
    "adventurous": "a dynamic and adventurous photo captured in an exciting moment",
    "mysterious": "a mysterious and enigmatic portrait shrouded in shadows and intrigue",
    "vintage": "a vintage-style portrait evoking the charm and nostalgia of a bygone era",
    "artistic": "an artistic and abstract representation blending creativity with visual storytelling",
    "futuristic": "a futuristic and cutting-edge portrayal set against advanced technology"
}

{
  "validation_preview": true,
  "validation_preview_steps": 1
}

[
  {
    "id": "pseudo-camera-10k-qwen",
    "type": "local",
    "crop": true,
    "crop_aspect": "square",
    "crop_style": "center",
    "resolution": 1024,
    "minimum_image_size": 512,
    "maximum_image_size": 1024,
    "target_downsample_size": 1024,
    "resolution_type": "pixel_area",
    "cache_dir_vae": "cache/vae/qwen_image/pseudo-camera-10k",
    "instance_data_dir": "datasets/pseudo-camera-10k",
    "disabled": false,
    "skip_file_discovery": "",
    "caption_strategy": "filename",
    "metadata_backend": "discovery",
    "repeats": 0,
    "is_regularisation_data": true
  },
  {
    "id": "dreambooth-subject",
    "type": "local",
    "crop": false,
    "resolution": 1024,
    "minimum_image_size": 512,
    "maximum_image_size": 1024,
    "target_downsample_size": 1024,
    "resolution_type": "pixel_area",
    "cache_dir_vae": "cache/vae/qwen_image/dreambooth-subject",
    "instance_data_dir": "datasets/dreambooth-subject",
    "caption_strategy": "instanceprompt",
    "instance_prompt": "the name of your subject goes here",
    "metadata_backend": "discovery",
    "repeats": 1000
  },
  {
    "id": "text-embeds",
    "type": "local",
    "dataset_type": "text_embeds",
    "default": true,
    "cache_dir": "cache/text/qwen_image",
    "disabled": false,
    "write_batch_size": 16
  }
]

mkdir -p datasets
pushd datasets
    huggingface-cli download --repo-type=dataset bghira/pseudo-camera-10k --local-dir=pseudo-camera-10k
    mkdir dreambooth-subject
    # place your images into dreambooth-subject/ now
popd

wandb login

huggingface-cli login

प्रशिक्षण रन निष्पादित करना¶

SimpleTuner डायरेक्टरी से, बस यह चलाएँ:

./train.sh

इससे text embed और VAE आउटपुट कैशिंग डिस्क पर शुरू होगी।

अधिक जानकारी के लिए dataloader और tutorial दस्तावेज़ देखें।

मेमोरी optimization टिप्स¶

सबसे कम VRAM कॉन्फ़िग (24GB न्यूनतम)¶

सबसे कम VRAM वाला Qwen Image कॉन्फ़िग लगभग 24GB मांगता है:

• OS: Ubuntu Linux 24
• GPU: एक NVIDIA CUDA डिवाइस (कम से कम 24GB)
• System memory: 64GB+ अनुशंसित
• Base model precision:
• NVIDIA सिस्टम्स के लिए: int2-quanto या nf4-bnb (24GB कार्ड्स के लिए आवश्यक)
• int4-quanto काम कर सकता है लेकिन गुणवत्ता कम हो सकती है
• Optimizer: मेमोरी दक्षता के लिए optimi-lion या bnb-lion8bit-paged
• Resolution: 512px या 768px से शुरू करें, मेमोरी अनुमति दे तो 1024px तक जाएँ
• Batch size: 1
• Gradient accumulation steps: 2‑8 से बड़े batch का अनुकरण करें
• --gradient_checkpointing सक्षम करें (अनिवार्य)
• Startup पर OOM से बचने के लिए --quantize_via=cpu उपयोग करें
• छोटा LoRA rank (1‑8) उपयोग करें
• environment variable PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True सेट करने से VRAM उपयोग कम होता है

नोट: VAE embeds और text encoder outputs की pre‑caching काफी मेमोरी उपयोग करेगी। यदि OOM हो तो offload_during_startup=true सक्षम करें।

बाद में LoRA पर inference चलाना¶

क्योंकि Qwen Image एक नया मॉडल है, यहाँ inference के लिए काम करने वाला उदाहरण है:

import torch
from diffusers import QwenImagePipeline, QwenImageTransformer2DModel
from transformers import Qwen2Tokenizer, Qwen2_5_VLForConditionalGeneration

model_id = 'Qwen/Qwen-Image'
adapter_id = 'your-username/your-lora-name'

# Load the pipeline
pipeline = QwenImagePipeline.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16
)

# Load LoRA weights
pipeline.load_lora_weights(adapter_id)

# Optional: quantize the model to save VRAM
from optimum.quanto import quantize, freeze, qint8
quantize(pipeline.transformer, weights=qint8)
freeze(pipeline.transformer)

# Move to device
pipeline.to('cuda' if torch.cuda.is_available() else 'cpu')

# Generate an image
prompt = "Your test prompt here"
negative_prompt = 'ugly, cropped, blurry, low-quality, mediocre average'

image = pipeline(
    prompt=prompt,
    negative_prompt=negative_prompt,
    num_inference_steps=30,
    guidance_scale=4.0,
    generator=torch.Generator(device='cuda').manual_seed(42),
    width=1024,
    height=1024,
).images[0]

image.save("output.png", format="PNG")

Notes & troubleshooting tips¶

Batch size limitations¶

पुराने diffusers Qwen builds में text embed padding और attention mask handling की वजह से batch size > 1 पर समस्याएँ थीं। SimpleTuner के मौजूदा Qwen overrides दोनों paths को patch करते हैं, इसलिए यदि VRAM अनुमति दे तो बड़े batches काम करते हैं। - train_batch_size केवल तभी बढ़ाएँ जब आपकी memory headroom पर्याप्त हो। - यदि किसी पुराने install पर artifacts दिखें, तो update करें और पुराने text embeds दोबारा generate करें।

Quantization¶

• int2-quanto सबसे आक्रामक मेमोरी बचत देता है लेकिन गुणवत्ता प्रभावित हो सकती है
• nf4-bnb मेमोरी और गुणवत्ता के बीच अच्छा संतुलन देता है
• int4-quanto मध्यम विकल्प है
• 40GB+ VRAM न हो तो int8 से बचें

Learning rates¶

LoRA प्रशिक्षण के लिए: - छोटे LoRAs (rank 1‑8): लगभग 1e‑4 learning rate - बड़े LoRAs (rank 16‑32): लगभग 5e‑5 learning rate - Prodigy optimizer के साथ: 1.0 से शुरू करें और इसे adapt करने दें

Image artifacts¶

यदि artifacts दिखें: - learning rate घटाएँ - gradient accumulation steps बढ़ाएँ - उच्च‑गुणवत्ता और सही तरह से preprocessed images सुनिश्चित करें - शुरुआत में कम resolutions उपयोग करने पर विचार करें

Multiple‑resolution training¶

शुरुआत में कम resolution (512px या 768px) पर training करें, फिर 1024px पर fine‑tune करें। अलग resolutions पर training करते समय --flow_schedule_auto_shift सक्षम करें।

Platform limitations¶

ये memory सुझाव NVIDIA GPUs के लिए हैं। अन्य प्लेटफॉर्म की dependencies और attention backends के लिए इंस्टॉलेशन गाइड देखें।

अधिक सहायता और troubleshooting के लिए SimpleTuner documentation देखें या community Discord जॉइन करें।

Qwen Image 2.1 की विधियाँ स्थानांतरित हो गई हैं¶

VRAM प्रीसेट

AnyFlow पायलट

ऑप्टिमाइज़र सुधार

सहायक बनाना

बहु-रिज़ॉल्यूशन सहायक

ऑफ़लाइन सहायक