FLUX.2 क्विकस्टार्ट¶

यह गाइड FLUX.2 पर LoRAs ट्रेन करने को कवर करती है, जो Black Forest Labs की नवीनतम इमेज जनरेशन मॉडल फैमिली है।

नोट: डिफ़ॉल्ट मॉडल फ्लेवर klein-9b है, लेकिन यह गाइड dev (24B Mistral-3 टेक्स्ट एन्कोडर वाला पूर्ण 12B transformer) पर केंद्रित है क्योंकि इसकी संसाधन आवश्यकताएँ सबसे अधिक हैं। Klein मॉडल चलाना आसान है - नीचे मॉडल वेरिएंट देखें।

मॉडल वेरिएंट¶

FLUX.2 तीन वेरिएंट में आता है:

मुख्य अंतर: - dev: स्टैंडअलोन Mistral-Small-3.1-24B टेक्स्ट एन्कोडर का उपयोग करता है, guidance embeddings हैं - klein मॉडल: मॉडल रिपॉजिटरी में शामिल Qwen3 टेक्स्ट एन्कोडर का उपयोग करते हैं, guidance embeddings नहीं (guidance ट्रेनिंग विकल्प अनदेखे होते हैं)

वेरिएंट चुनने के लिए, अपनी config में model_flavour सेट करें:

{
  "model_flavour": "dev"
}

महत्वपूर्ण: klein-4b और klein-9b के लिए bundled Qwen3 text encoder उपयोग करने के लिए qwen_text_encoder_model_name_or_path को unset छोड़ें। इसे केवल तब सेट करें जब bundled Qwen3 text encoder को किसी दूसरे Qwen-compatible source से बदलना हो।

मॉडल ओवरव्यू¶

FLUX.2-dev, FLUX.1 से बड़े आर्किटेक्चरल बदलाव लाता है:

• Text Encoder: Mistral-Small-3.1-24B (dev) या Qwen3 (klein)
• Architecture: 8 DoubleStreamBlocks + 48 SingleStreamBlocks (dev)
• Latent Channels: 32 VAE चैनल → pixel shuffle के बाद 128 (FLUX.1 में 16)
• VAE: batch normalization और pixel shuffling वाला custom VAE
• Embedding Dimension: dev के लिए 15,360 (3×5,120), klein-9b के लिए 12,288 (3×4,096), klein-4b के लिए 7,680 (3×2,560)

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

हार्डवेयर आवश्यकताएँ मॉडल वेरिएंट के अनुसार काफी भिन्न होती हैं।

Klein मॉडल (अधिकांश उपयोगकर्ताओं के लिए अनुशंसित)¶

Klein मॉडल अधिक सुलभ हैं:

klein-9b के लिए अनुशंसित: एकल 24GB GPU (RTX 3090/4090, A5000) klein-4b के लिए अनुशंसित: एकल 16GB GPU (RTX 4080, A4000)

FLUX.2-dev (उन्नत)¶

Mistral-3 टेक्स्ट एन्कोडर के कारण FLUX.2-dev को काफी संसाधन चाहिए:

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

24B Mistral text encoder को अकेले भी काफी VRAM चाहिए:

System RAM¶

• Minimum: 96GB सिस्टम RAM (24B टेक्स्ट एन्कोडर लोड करने के लिए पर्याप्त मेमोरी चाहिए)
• Recommended: आरामदायक ऑपरेशन के लिए 128GB+

अनुशंसित हार्डवेयर¶

• Minimum: 2x 48GB GPUs (A6000, L40S) FSDP2 या DeepSpeed के साथ
• Recommended: 4x H100 80GB with fp8-torchao
• Heavy quantization (int4) के साथ: 2x 24GB GPUs संभव हैं लेकिन experimental

Mistral-3 टेक्स्ट एन्कोडर और transformer के संयुक्त आकार के कारण FLUX.2-dev के लिए multi-GPU distributed training (FSDP2 या DeepSpeed) लगभग अनिवार्य है।

प्रीरिक्विज़िट्स¶

Python वर्ज़न¶

FLUX.2 को Python 3.10 या उससे नया और हाल के transformers चाहिए:

python --version  # Should be 3.10+
pip install transformers>=4.45.0

मॉडल एक्सेस¶

FLUX.2 मॉडल के लिए Hugging Face पर access approval चाहिए:

dev के लिए: 1. black-forest-labs/FLUX.2-dev पर जाएँ 2. License agreement स्वीकार करें

klein मॉडल के लिए: 1. black-forest-labs/FLUX.2-klein-base-9B या black-forest-labs/FLUX.2-klein-base-4B पर जाएँ 2. License agreement स्वीकार करें

सुनिश्चित करें कि आप Hugging Face CLI में लॉगिन हैं: huggingface-cli login

इंस्टॉलेशन¶

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

Development setup के लिए:

git clone https://github.com/bghira/SimpleTuner
cd SimpleTuner
pip install -e ".[cuda]"

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

Web Interface¶

simpletuner server

http://localhost:8001 खोलें और model family के रूप में FLUX.2 चुनें।

Manual Configuration¶

config/config.json बनाएं:

{
  "model_type": "lora",
  "model_family": "flux2",
  "model_flavour": "dev",
  "pretrained_model_name_or_path": "black-forest-labs/FLUX.2-dev",
  "output_dir": "/path/to/output",
  "train_batch_size": 1,
  "gradient_accumulation_steps": 1,
  "gradient_checkpointing": true,
  "mixed_precision": "bf16",
  "learning_rate": 1e-4,
  "lr_scheduler": "constant",
  "max_train_steps": 10000,
  "validation_resolution": "1024x1024",
  "validation_num_inference_steps": 20,
  "flux_guidance_mode": "constant",
  "flux_guidance_value": 1.0,
  "lora_rank": 16
}

प्रमुख कॉन्फ़िगरेशन विकल्प¶

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

नोट: Klein मॉडल (klein-4b, klein-9b) में guidance embeddings नहीं होते। निम्नलिखित guidance विकल्प केवल dev पर लागू होते हैं।

FLUX.2-dev, FLUX.1 की तरह guidance embedding उपयोग करता है:

{
  "flux_guidance_mode": "constant",
  "flux_guidance_value": 1.0
}

या ट्रेनिंग के दौरान random guidance के लिए:

{
  "flux_guidance_mode": "random-range",
  "flux_guidance_min": 1.0,
  "flux_guidance_max": 5.0
}

Quantization (Memory Optimization)¶

VRAM कम करने के लिए:

{
  "base_model_precision": "int8-quanto",
  "text_encoder_1_precision": "int8-quanto",
  "base_model_default_dtype": "bf16"
}

TREAD (Training Acceleration)¶

FLUX.2 तेज़ ट्रेनिंग के लिए TREAD सपोर्ट करता है:

{
  "tread_config": {
    "routes": [
      {"selection_ratio": 0.5, "start_layer_idx": 2, "end_layer_idx": -2}
    ]
  }
}

उन्नत प्रयोगात्मक फीचर्स¶

डेटासेट कॉन्फ़िगरेशन¶

config/multidatabackend.json बनाएं:

[
  {
    "id": "my-dataset",
    "type": "local",
    "crop": true,
    "crop_aspect": "square",
    "crop_style": "center",
    "resolution": 1024,
    "minimum_image_size": 1024,
    "maximum_image_size": 1024,
    "resolution_type": "pixel_area",
    "cache_dir_vae": "cache/vae/flux2/my-dataset",
    "instance_data_dir": "datasets/my-dataset",
    "caption_strategy": "textfile",
    "metadata_backend": "discovery",
    "repeats": 10
  },
  {
    "id": "text-embeds",
    "type": "local",
    "dataset_type": "text_embeds",
    "default": true,
    "cache_dir": "cache/text/flux2",
    "write_batch_size": 64
  }
]

caption_strategy विकल्पों और आवश्यकताओं के लिए DATALOADER.md देखें।

वैकल्पिक edit / reference conditioning¶

FLUX.2 plain text-to-image (बिना conditioning) या paired reference/edit images के साथ ट्रेन कर सकता है। conditioning जोड़ने के लिए अपने मुख्य डेटासेट को एक या अधिक conditioning datasets से conditioning_data के जरिए जोड़ें और conditioning_type चुनें:

[
  {
    "id": "flux2-edits",
    "type": "local",
    "instance_data_dir": "/datasets/flux2/edits",
    "caption_strategy": "textfile",
    "resolution": 1024,
    "conditioning_data": ["flux2-references"],
    "cache_dir_vae": "cache/vae/flux2/edits"
  },
  {
    "id": "flux2-references",
    "type": "local",
    "dataset_type": "conditioning",
    "instance_data_dir": "/datasets/flux2/references",
    "conditioning_type": "reference_strict",
    "resolution": 1024,
    "cache_dir_vae": "cache/vae/flux2/references"
  }
]

• जब edit इमेज के साथ 1:1 crop alignment चाहिए, तब conditioning_type=reference_strict उपयोग करें। reference_loose mismatched aspect ratios की अनुमति देता है।
• edit और reference datasets के बीच फ़ाइल नामों का मेल होना चाहिए; हर edit इमेज की एक संबंधित reference फ़ाइल होनी चाहिए।
• कई conditioning datasets देने पर conditioning_multidataset_sampling (combined बनाम random) जरूरत अनुसार सेट करें; OPTIONS देखें।
• conditioning_data के बिना, FLUX.2 standard text-to-image training पर लौट आता है।

LoRA Targets¶

उपलब्ध LoRA target presets:

• all (डिफ़ॉल्ट): सभी attention और MLP layers
• attention: केवल attention layers (qkv, proj)
• mlp: केवल MLP/feed-forward layers
• tiny: न्यूनतम ट्रेनिंग (केवल qkv layers)

{
  "--flux_lora_target": "all"
}

ट्रेनिंग¶

सेवाओं में लॉगिन¶

huggingface-cli login
wandb login  # optional

ट्रेनिंग शुरू करें¶

simpletuner train

या script से:

./train.sh

Validation Prompts¶

config/user_prompt_library.json बनाएं:

{
  "portrait_subject": "a professional portrait photograph of <subject>, studio lighting, high detail",
  "artistic_subject": "an artistic interpretation of <subject> in the style of renaissance painting",
  "cinematic_subject": "a cinematic shot of <subject>, dramatic lighting, film grain"
}

Inference¶

Trained LoRA का उपयोग¶

FLUX.2 LoRAs को SimpleTuner inference pipeline या community support विकसित होने पर compatible tools से लोड किया जा सकता है।

Guidance Scale¶

• flux_guidance_value=1.0 के साथ ट्रेनिंग अधिकांश use cases के लिए ठीक रहती है
• inference पर सामान्य guidance values (3.0-5.0) उपयोग करें

FLUX.1 से अंतर¶

Troubleshooting¶

Startup के दौरान Out of Memory¶

• --offload_during_startup=true सक्षम करें
• text encoder quantization के लिए --quantize_via=cpu उपयोग करें
• --vae_batch_size घटाएँ

धीमे text embeddings¶

Mistral-3 बड़ा है; विचार करें: - ट्रेनिंग से पहले सभी text embeddings pre-cache करें - text encoder quantization उपयोग करें - बड़े write_batch_size के साथ batch processing

ट्रेनिंग अस्थिरता¶

• learning rate कम करें (5e-5 आज़माएँ)
• gradient accumulation steps बढ़ाएँ
• gradient checkpointing सक्षम करें
• --max_grad_norm=1.0 उपयोग करें

CUDA Out of Memory¶

• quantization सक्षम करें (int8-quanto या int4-quanto)
• gradient checkpointing सक्षम करें
• batch size घटाएँ
• token routing efficiency के लिए TREAD उपयोग करें

Advanced: TREAD कॉन्फ़िगरेशन¶

TREAD (Token Routing for Efficient Architecture-agnostic Diffusion) चुनिंदा tokens प्रोसेस करके ट्रेनिंग को तेज़ करता है:

{
  "tread_config": {
    "routes": [
      {
        "selection_ratio": 0.5,
        "start_layer_idx": 4,
        "end_layer_idx": -4
      }
    ]
  }
}

• selection_ratio: रखें जाने वाले tokens का हिस्सा (0.5 = 50%)
• start_layer_idx: routing लागू करने की पहली layer
• end_layer_idx: आख़िरी layer (negative = end से)

Expected speedup: configuration पर निर्भर 20-40%.

See Also¶

• FLUX.1 Quickstart - FLUX.1 training के लिए
• TREAD Documentation - विस्तृत TREAD कॉन्फ़िगरेशन
• LyCORIS Training Guide - LoRA और LyCORIS प्रशिक्षण विधियाँ
• Dataloader Configuration - डेटासेट सेटअप