> 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/image-generation/flux.md).

# FLUX.1

{% hint style="info" %}
**तेज़ विकल्प!** [**FLUX.2 Klein**](/guides/guides_v2-hi/image-generation/flux2-klein.md) < 0.5 सेकंड में चित्र बनाता है (FLUX.1 के लिए 10–30 सेकंड की तुलना में) और समान गुणवत्ता देता है। यह गाइड LoRA प्रशिक्षण और ControlNet वर्कफ़्लो के लिए अभी भी प्रासंगिक है।
{% endhint %}

CLORE.AI GPUs पर Black Forest Labs का अत्याधुनिक इमेज जनरेशन मॉडल।

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

## FLUX.1 क्यों?

* **सर्वोत्तम गुणवत्ता** - SDXL और Midjourney v5 से बेहतर
* **टेक्स्ट रेंडरिंग** - चित्रों में वास्तव में पढ़ने योग्य टेक्स्ट
* **प्रॉम्प्ट का पालन** - उत्कृष्ट निर्देश अनुपालन
* **तेज़ वेरिएंट** - त्वरित जनरेशन के लिए FLUX.1-schnell

## मॉडल वैरिएंट्स

| मॉडल           | गति            | गुणवत्ता   | VRAM  | लाइसेंस        |
| -------------- | -------------- | ---------- | ----- | -------------- |
| FLUX.1-schnell | तेज़ (4 चरण)   | बहुत अच्छा | 12GB+ | Apache 2.0     |
| FLUX.1-dev     | मध्यम (20 चरण) | उत्कृष्ट   | 16GB+ | गैर-व्यावसायिक |
| FLUX.1-pro     | केवल API       | सर्वोत्तम  | -     | व्यावसायिक     |

## CLORE.AI पर त्वरित परिनियोजन

**Docker इमेज:**

```
ghcr.io/huggingface/text-generation-inference:latest
```

**पोर्ट्स:**

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

सबसे आसान डिप्लॉयमेंट के लिए, उपयोग करें **FLUX नोड्स के साथ ComfyUI**.

## इंस्टॉलेशन विधियाँ

### विधि 1: ComfyUI (अनुशंसित)

```bash
# ComfyUI इंस्टॉल करें
git clone https://github.com/comfyanonymous/ComfyUI
cd ComfyUI
pip install -r requirements.txt

# FLUX मॉडल डाउनलोड करें
cd models/unet
wget https://huggingface.co/black-forest-labs/FLUX.1-schnell/resolve/main/flux1-schnell.safetensors

# आवश्यक घटक डाउनलोड करें
cd ../clip
wget https://huggingface.co/comfyanonymous/flux_text_encoders/resolve/main/clip_l.safetensors
wget https://huggingface.co/comfyanonymous/flux_text_encoders/resolve/main/t5xxl_fp16.safetensors

cd ../vae
wget https://huggingface.co/black-forest-labs/FLUX.1-schnell/resolve/main/ae.safetensors

# ComfyUI चलाएँ
python main.py --listen 0.0.0.0
```

### विधि 2: Diffusers

```bash
pip install diffusers transformers accelerate torch

python << 'PYEOF'
import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

image = pipe(
    "मंगल ग्रह पर स्पेस सूट पहने एक बिल्ली",
    num_inference_steps=4,
    guidance_scale=0.0,
).images[0]

image.save("flux_output.png")
PYEOF
```

### विधि 3: Fooocus

Fooocus में बिल्ट-इन FLUX समर्थन है:

```bash
git clone https://github.com/lllyasviel/Fooocus
cd Fooocus
pip install -r requirements.txt

# FLUX मॉडल को models/checkpoints/ में डाउनलोड करें
python launch.py --listen
```

## ComfyUI वर्कफ़्लो

### FLUX.1-schnell (तेज़)

आवश्यक नोड्स:

1. **Load Diffusion Model** → flux1-schnell.safetensors
2. **DualCLIPLoader** → clip\_l.safetensors + t5xxl\_fp16.safetensors
3. **CLIP Text Encode** → आपका प्रॉम्प्ट
4. **Empty SD3 Latent Image** → आयाम सेट करें
5. **KSampler** → steps: 4, cfg: 1.0
6. **VAE Decode** → ae.safetensors
7. **Save Image**

### FLUX.1-dev (गुणवत्ता)

वही वर्कफ़्लो, लेकिन:

* चरण: 20-50
* CFG: 3.5
* प्रॉम्प्ट में guidance\_scale का उपयोग करें

## Python API

### बुनियादी जनरेशन

```python
import torch
from diffusers import FluxPipeline

# मॉडल लोड करें
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)
pipe.to("cuda")

# जनरेट करें
image = pipe(
    prompt="चेरी ब्लॉसम के साथ एक शांत जापानी उद्यान",
    height=1024,
    width=1024,
    num_inference_steps=4,
    guidance_scale=0.0,
).images[0]

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

### मेमोरी ऑप्टिमाइज़ेशन के साथ

```python
from diffusers import FluxPipeline
import torch

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)

# ऑप्टिमाइज़ेशन सक्षम करें
pipe.enable_model_cpu_offload()  # ~10GB VRAM बचाता है
pipe.enable_vae_slicing()
pipe.enable_vae_tiling()

image = pipe(
    "एक साइबरपंक समुराई का पोर्ट्रेट",
    height=1024,
    width=1024,
    num_inference_steps=4,
).images[0]
```

### बैच जनरेशन

```python
prompts = [
    "पहाड़ों के ऊपर सूर्यास्त",
    "रात में एक भविष्यवादी शहर",
    "एक पानी के अंदर का कोरल रीफ़",
]

images = pipe(
    prompts,
    height=1024,
    width=1024,
    num_inference_steps=4,
).images

for i, img in enumerate(images):
    img.save(f"output_{i}.png")
```

## FLUX.1-dev (उच्च गुणवत्ता)

```python
from diffusers import FluxPipeline
import torch

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

image = pipe(
    prompt="एक बुज़ुर्ग मछुआरे का अति-यथार्थवादी पोर्ट्रेट",
    height=1024,
    width=1024,
    num_inference_steps=50,
    guidance_scale=3.5,
).images[0]
```

## प्रॉम्प्ट सुझाव

### FLUX इसमें उत्कृष्ट है:

* **चित्रों में टेक्स्ट**: "'OPEN 24/7' लिखता हुआ एक नीयन साइन"
* **जटिल दृश्य**: "रात में एक व्यस्त टोक्यो सड़क, प्रतिबिंबों के साथ"
* **विशिष्ट शैलियाँ**: "मॉने की शैली में तेल चित्रकला"
* **विस्तृत विवरण**: लंबे, विस्तृत प्रॉम्प्ट अच्छी तरह काम करते हैं

### उदाहरण प्रॉम्प्ट

```
# फोटोरियलिस्टिक
शरद ऋतु की पत्तियों में खेलते हुए गोल्डन रिट्रीवर पिल्ले की एक पेशेवर फ़ोटोग्राफ़, 
shalllow depth of field, गर्म दोपहर की रोशनी, Canon EOS R5

# कलात्मक
बारिश में एक पेरिसियन कैफ़े की एक इम्प्रेशनिस्ट पेंटिंग, 
कैनवास पर तेल, दिखाई देने वाले ब्रशस्ट्रोक, गर्म रंग

# टेक्स्ट रेंडरिंग
बोल्ड रेट्रो अक्षरों में शीर्षक "COSMIC VOYAGE" के साथ एक विंटेज मूवी पोस्टर,
1960 के दशक की साइ-फ़ाइ शैली, अंतरिक्ष यात्री चित्रण

# जटिल दृश्य
फर्श से छत तक किताबों की अलमारियों वाला एक आरामदायक पुस्तकालय इंटीरियर, 
फायरप्लेस के पास एक लेदर आर्मचेयर, खिड़की से दिखाई देती बारिश,
गर्म लैंप रोशनी, फोटोरियलिस्टिक
```

## मेमोरी ऑप्टिमाइज़ेशन

### 12GB VRAM (RTX 3060) के लिए

```python
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.float16  # bf16 की जगह fp16 का उपयोग करें
)
pipe.enable_model_cpu_offload()
pipe.enable_vae_slicing()
pipe.enable_vae_tiling()

# कम रेज़ोल्यूशन पर जनरेट करें
image = pipe(prompt, height=768, width=768, num_inference_steps=4).images[0]
```

### 8GB VRAM के लिए

quantized संस्करण या GGUF के साथ ComfyUI का उपयोग करें:

```bash
# ComfyUI में GGUF नोड्स इंस्टॉल करें
cd custom_nodes
git clone https://github.com/city96/ComfyUI-GGUF

# quantized मॉडल डाउनलोड करें
wget https://huggingface.co/city96/FLUX.1-schnell-gguf/resolve/main/flux1-schnell-Q4_K_S.gguf
```

## प्रदर्शन तुलना

| मॉडल           | चरण | समय (4090) | गुणवत्ता   |
| -------------- | --- | ---------- | ---------- |
| FLUX.1-schnell | 4   | \~3 सेकंड  | बहुत अच्छा |
| FLUX.1-dev     | 20  | \~12 सेकंड | उत्कृष्ट   |
| FLUX.1-dev     | 50  | \~30 सेकंड | सर्वोत्तम  |
| SDXL           | 30  | \~8 सेकंड  | अच्छा      |

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

| सेटअप              | न्यूनतम | अनुशंसित |
| ------------------ | ------- | -------- |
| FLUX.1-schnell     | 12GB    | 16GB+    |
| FLUX.1-dev         | 16GB    | 24GB+    |
| CPU offload के साथ | 8GB     | 12GB+    |
| Quantized (GGUF)   | 6GB     | 8GB+     |

## GPU प्रीसेट्स

### RTX 3060 12GB (बजट)

```python
# quantized मॉडल का उपयोग करें
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.float16
)
pipe.enable_model_cpu_offload()
pipe.enable_vae_tiling()

# सेटिंग्स:
# - केवल schnell (dev OOM हो सकता है)
# - 512x512 से 768x768
# - 4 चरण
# - बैच साइज़ 1
```

### RTX 3090 24GB (इष्टतम)

```python
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_vae_tiling()

# सेटिंग्स:
# - schnell: 1024x1024, बैच 2
# - dev: 1024x1024, बैच 1
# - dev के लिए 20-30 चरण
# - उच्च रिज़ोल्यूशन के लिए VAE tiling सक्षम करें
```

### [RTX 4090 24GB](https://clore.ai/rent-4090.html?utm_source=docs\&utm_medium=guide\&utm_campaign=flux) (प्रदर्शन)

```python
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.float16
)
pipe.to("cuda")

# सेटिंग्स:
# - schnell: 1024x1024, बैच 4
# - dev: 1024x1024, बैच 2
# - सर्वोत्तम गुणवत्ता के लिए 30-50 चरण
# - tiling के साथ 1536x1536 कर सकता है
```

### A100 40GB/80GB (प्रोडक्शन)

```python
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16
)
pipe.to("cuda")

# सेटिंग्स:
# - schnell: 1024x1024, बैच 8+
# - dev: 1024x1024, बैच 4
# - अधिकतम गुणवत्ता के लिए 50 चरण
# - 2048x2048 संभव
```

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

| GPU           | प्रति घंटा | चित्र/घंटा       |
| ------------- | ---------- | ---------------- |
| RTX 3060 12GB | \~$0.03    | \~200 (schnell)  |
| RTX 3090 24GB | \~$0.06    | \~600 (schnell)  |
| RTX 4090 24GB | \~$0.10    | \~1000 (schnell) |
| A100 40GB     | \~$0.17    | \~1500 (schnell) |

## Troubleshooting

### मेमोरी समाप्त

```python
# CPU offload का उपयोग करें
pipe.enable_model_cpu_offload()

# या sequential CPU offload (धीमा, लेकिन कम VRAM)
pipe.enable_sequential_cpu_offload()

# रिज़ोल्यूशन कम करें
height=768, width=768
```

### धीमी जनरेशन

* FLUX.1-schnell (4 चरण) का उपयोग करें
* torch.compile सक्षम करें: `pipe.unet = torch.compile(pipe.unet)`
* पुराने GPUs पर bf16 की जगह fp16 का उपयोग करें

### खराब गुणवत्ता

* अधिक चरणों का उपयोग करें (FLUX-dev: 30-50)
* guidance\_scale बढ़ाएँ (dev के लिए 3.0-4.0)
* अधिक विस्तृत प्रॉम्प्ट लिखें

***

## FLUX LoRA

LoRA (Low-Rank Adaptation) वज़न आपको पूर्ण मॉडल को दोबारा प्रशिक्षित किए बिना FLUX को विशिष्ट शैलियों, पात्रों, या कॉन्सेप्ट्स के लिए fine-tune करने देते हैं। HuggingFace और CivitAI पर समुदाय के सैकड़ों LoRA उपलब्ध हैं।

### स्थापना

```bash
pip install diffusers transformers accelerate peft
```

### एक सिंगल LoRA लोड करना

```python
import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

# एक स्थानीय फ़ाइल से LoRA वज़न लोड करें
pipe.load_lora_weights("path/to/lora.safetensors")

image = pipe(
    "वैन गॉग की शैली में एक पोर्ट्रेट, घूमते हुए ब्रशस्ट्रोक",
    num_inference_steps=20,
    guidance_scale=3.5,
    generator=torch.Generator(device="cuda").manual_seed(42),
).images[0]
image.save("flux_lora_output.png")
```

### HuggingFace Hub से लोड करना

```python
import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

# LoRA को सीधे HuggingFace repo से लोड करें
pipe.load_lora_weights(
    "username/my-flux-lora",          # HF repo ID
    weight_name="my_lora.safetensors" # repo में फ़ाइल नाम
)

image = pipe(
    "trigger_word एक सुंदर परिदृश्य",
    num_inference_steps=20,
    guidance_scale=3.5,
).images[0]
image.save("output.png")
```

### LoRA स्केल (ताकत)

```python
# cross_attention_kwargs के साथ LoRA प्रभाव नियंत्रित करें
image = pipe(
    "एक साइबरपंक पात्र, नीयन लाइट्स",
    num_inference_steps=20,
    guidance_scale=3.5,
    cross_attention_kwargs={"scale": 0.8},  # 0.0 = कोई प्रभाव नहीं, 1.0 = पूर्ण प्रभाव
).images[0]
```

### कई LoRAs को मिलाना

```python
from diffusers import FluxPipeline
import torch

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

# पहला LoRA लोड करें
pipe.load_lora_weights(
    "path/to/style_lora.safetensors",
    adapter_name="style"
)

# दूसरा LoRA लोड करें
pipe.load_lora_weights(
    "path/to/character_lora.safetensors",
    adapter_name="character"
)

# वज़नों के साथ संयोजित करें
pipe.set_adapters(["style", "character"], adapter_weights=[0.7, 0.9])

image = pipe(
    "character_trigger विस्तृत पोशाक पहने, artistic_trigger शैली",
    num_inference_steps=25,
    guidance_scale=3.5,
).images[0]
image.save("combined_lora.png")
```

### LoRA अनलोड करना

```python
# बेस मॉडल को पुनर्स्थापित करने के लिए LoRA वज़न हटाएँ
pipe.unload_lora_weights()
```

### अपना FLUX LoRA प्रशिक्षित करना

```bash
# FLUX LoRA प्रशिक्षण के लिए kohya-ss या ai-toolkit का उपयोग करें
git clone https://github.com/ostris/ai-toolkit
cd ai-toolkit
pip install -r requirements.txt

# डेटासेट तैयार करें: कैप्शन के साथ 10-30 चित्र
# config YAML संपादित करें, फिर:
python run.py config/flux_lora_train.yaml
```

### अनुशंसित LoRA स्रोत

| स्रोत       | URL                   | नोट्स                        |
| ----------- | --------------------- | ---------------------------- |
| CivitAI     | civitai.com           | बड़ा समुदाय लाइब्रेरी        |
| HuggingFace | huggingface.co/models | FLUX के अनुसार फ़िल्टर करें  |
| Replicate   | replicate.com         | प्रशिक्षित मॉडल ब्राउज़ करें |

***

## FLUX के लिए ControlNet

ControlNet, canny edges, depth maps, और pose skeletons जैसे संरचनात्मक इनपुट के साथ FLUX जनरेशन को मार्गदर्शन करने देता है। XLabs-AI ने विशेष रूप से FLUX.1 के लिए पहले ControlNet मॉडल जारी किए हैं।

### स्थापना

```bash
pip install diffusers transformers accelerate controlnet-aux pillow
```

### FLUX ControlNet Canny (XLabs-AI)

```python
import torch
import numpy as np
from PIL import Image
from diffusers import FluxControlNetPipeline, FluxControlNetModel
from diffusers.utils import load_image
from controlnet_aux import CannyDetector

# FLUX ControlNet मॉडल (Canny variant) लोड करें
controlnet = FluxControlNetModel.from_pretrained(
    "XLabs-AI/flux-controlnet-canny-diffusers",
    torch_dtype=torch.bfloat16
)

# ControlNet के साथ पाइपलाइन लोड करें
pipe = FluxControlNetPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    controlnet=controlnet,
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

# कंट्रोल इमेज तैयार करें (canny edges)
input_image = load_image("your_input.jpg").resize((1024, 1024))
canny = CannyDetector()
control_image = canny(input_image, low_threshold=50, high_threshold=200)

# ControlNet guidance के साथ जनरेट करें
image = pipe(
    prompt="नीयन साइन के साथ एक भविष्यवादी सिटीस्केप, फोटोरियलिस्टिक, 8K",
    control_image=control_image,
    controlnet_conditioning_scale=0.7,
    num_inference_steps=25,
    guidance_scale=3.5,
    generator=torch.Generator(device="cuda").manual_seed(0),
).images[0]

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

### FLUX ControlNet Depth

```python
import torch
from PIL import Image
from diffusers import FluxControlNetPipeline, FluxControlNetModel
from diffusers.utils import load_image
from transformers import pipeline as hf_pipeline

# depth estimator लोड करें
depth_estimator = hf_pipeline("depth-estimation", model="LiheYoung/depth-anything-small-hf")

# depth map तैयार करें
input_image = load_image("portrait.jpg").resize((1024, 1024))
depth_result = depth_estimator(input_image)["depth"]
depth_image = depth_result.convert("RGB")

# ControlNet Depth लोड करें
controlnet = FluxControlNetModel.from_pretrained(
    "XLabs-AI/flux-controlnet-depth-diffusers",
    torch_dtype=torch.bfloat16
)

pipe = FluxControlNetPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    controlnet=controlnet,
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

image = pipe(
    prompt="एक योद्धा की संगमरमर की मूर्ति, नाटकीय प्रकाश, संग्रहालय फ़ोटो",
    control_image=depth_image,
    controlnet_conditioning_scale=0.6,
    num_inference_steps=20,
    guidance_scale=3.5,
).images[0]
image.save("depth_controlnet_output.png")
```

### FLUX के लिए Multi-ControlNet

```python
import torch
from diffusers import FluxControlNetPipeline, FluxMultiControlNetModel, FluxControlNetModel
from diffusers.utils import load_image
from controlnet_aux import CannyDetector

# कई ControlNets लोड करें
controlnet_canny = FluxControlNetModel.from_pretrained(
    "XLabs-AI/flux-controlnet-canny-diffusers",
    torch_dtype=torch.bfloat16
)
controlnet_depth = FluxControlNetModel.from_pretrained(
    "XLabs-AI/flux-controlnet-depth-diffusers",
    torch_dtype=torch.bfloat16
)

# MultiControlNet में संयोजित करें
multi_controlnet = FluxMultiControlNetModel([controlnet_canny, controlnet_depth])

pipe = FluxControlNetPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    controlnet=multi_controlnet,
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

image = pipe(
    prompt="कवच पहने एक शूरवीर जंगल में खड़ा है, नाटकीय प्रकाश",
    control_image=[canny_image, depth_image],
    controlnet_conditioning_scale=[0.7, 0.5],
    num_inference_steps=25,
    guidance_scale=3.5,
).images[0]
```

### उपलब्ध FLUX ControlNet मॉडल

| मॉडल          | Repo                                        | उपयोग का मामला           |
| ------------- | ------------------------------------------- | ------------------------ |
| Canny         | XLabs-AI/flux-controlnet-canny-diffusers    | किनारे-निर्देशित जनरेशन  |
| Depth         | XLabs-AI/flux-controlnet-depth-diffusers    | गहराई-निर्देशित जनरेशन   |
| HED/Soft Edge | XLabs-AI/flux-controlnet-hed-diffusers      | मृदु संरचनात्मक नियंत्रण |
| Pose          | XLabs-AI/flux-controlnet-openpose-diffusers | पोज़-निर्देशित पोर्ट्रेट |

### ControlNet सुझाव

* **conditioning\_scale 0.5–0.8** FLUX के लिए सबसे अच्छा काम करता है (बहुत अधिक होने पर रचनात्मकता कम हो जाती है)
* उपयोग करें **1024×1024** या सर्वोत्तम गुणवत्ता के लिए multiples
* शैली + संरचना नियंत्रण के लिए LoRA के साथ संयोजित करें
* ControlNet के साथ कम चरण (20–25) आमतौर पर पर्याप्त होते हैं

***

## FLUX.1-schnell: तेज जनरेशन मोड

FLUX.1-schnell, FLUX का distilled, गति-अनुकूलित वेरिएंट है। यह उच्च-गुणवत्ता वाले चित्र सिर्फ **4 चरणों** में बनाता है (FLUX.1-dev के 20–50 की तुलना में), जिससे यह त्वरित प्रोटोटाइपिंग और उच्च-थ्रूपुट वर्कफ़्लो के लिए आदर्श है।

### FLUX.1-dev की तुलना में मुख्य अंतर

| विशेषता         | FLUX.1-schnell                     | FLUX.1-dev     |
| --------------- | ---------------------------------- | -------------- |
| चरण             | 4                                  | 20–50          |
| गति (4090)      | \~3 सेकंड                          | \~12–30 सेकंड  |
| लाइसेंस         | **Apache 2.0** (मुफ़्त व्यावसायिक) | गैर-व्यावसायिक |
| guidance\_scale | 0.0 (कोई CFG नहीं)                 | 3.5            |
| गुणवत्ता        | बहुत अच्छा                         | उत्कृष्ट       |
| VRAM            | 12GB+                              | 16GB+          |

> **लाइसेंस नोट:** FLUX.1-schnell Apache 2.0 है — आप इसे व्यावसायिक उत्पादों में स्वतंत्र रूप से उपयोग कर सकते हैं। FLUX.1-dev के लिए Black Forest Labs से अलग व्यावसायिक लाइसेंस चाहिए।

### क्विक स्टार्ट

```python
import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

image = pipe(
    prompt="गोल्डन आवर में न्यूयॉर्क सिटी का एक शानदार एरियल व्यू, फोटोरियलिस्टिक",
    height=1024,
    width=1024,
    num_inference_steps=4,   # केवल 4 चरणों की ज़रूरत है!
    guidance_scale=0.0,       # schnell के लिए CFG अक्षम
    max_sequence_length=256,
    generator=torch.Generator(device="cpu").manual_seed(0),
).images[0]

image.save("schnell_output.png")
print("RTX 4090 पर ~3 सेकंड में जनरेट हुआ!")
```

### उच्च-थ्रूपुट बैच जनरेशन

```python
import torch
from diffusers import FluxPipeline
from pathlib import Path

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)
pipe.to("cuda")  # गति के लिए GPU पर रखें, cpu_offload का उपयोग न करें

output_dir = Path("schnell_outputs")
output_dir.mkdir(exist_ok=True)

prompts = [
    "सुबह के समय एक शांत पहाड़ी झील, धुंधला वातावरण",
    "रात में एक चहल-पहल वाला टोक्यो सड़क बाज़ार, नीयन प्रतिबिंब",
    "ओस से ढके मकड़ी के जाले की मैक्रो फ़ोटोग्राफ़",
    "तैरती हुई किताबों और जादुई रोशनी वाला एक प्राचीन पुस्तकालय",
    "जैवदीप्त समुद्री जीवन के साथ एक भविष्यवादी पानी के नीचे का शहर",
]

# बैच जनरेशन
for i, prompt in enumerate(prompts):
    image = pipe(
        prompt=prompt,
        height=1024,
        width=1024,
        num_inference_steps=4,
        guidance_scale=0.0,
        generator=torch.Generator(device="cuda").manual_seed(i),
    ).images[0]
    image.save(output_dir / f"image_{i:04d}.png")
    print(f"{i+1}/{len(prompts)} जनरेट हुआ: {prompt[:50]}...")
```

### schnell के साथ कई aspect ratios

```python
import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

# FLUX लचीले aspect ratios का समर्थन करता है
resolutions = {
    "square":    (1024, 1024),
    "portrait":  (768,  1360),
    "landscape": (1360, 768),
    "tall":      (576,  1792),
    "wide":      (1792, 576),
}

prompt = "बर्फीले जंगल में एक भेड़िया, पेशेवर वन्यजीव फ़ोटोग्राफ़ी"

for name, (width, height) in resolutions.items():
    image = pipe(
        prompt=prompt,
        height=height,
        width=width,
        num_inference_steps=4,
        guidance_scale=0.0,
    ).images[0]
    image.save(f"schnell_{name}.png")
    print(f"{name} सहेजा गया: {width}x{height}")
```

### मेमोरी ऑप्टिमाइज़ेशन के साथ schnell

```python
import torch
from diffusers import FluxPipeline

# 12GB VRAM (RTX 3060/3080) के लिए
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.float16  # fp16 पुराने GPUs पर मेमोरी बचाता है
)
pipe.enable_model_cpu_offload()
pipe.enable_vae_slicing()
pipe.enable_vae_tiling()

image = pipe(
    prompt="पतझड़ के जंगल में एक आरामदायक केबिन, खिड़कियों से आती गर्म रोशनी",
    height=768,
    width=768,
    num_inference_steps=4,
    guidance_scale=0.0,
).images[0]
image.save("schnell_low_vram.png")
```

### प्रदर्शन बेंचमार्क (schnell)

| GPU           | VRAM | समय/चित्र (1024px) | चित्र/घंटा |
| ------------- | ---- | ------------------ | ---------- |
| RTX 3060 12GB | 12GB | \~8 सेकंड          | \~450      |
| RTX 3090 24GB | 24GB | \~4 सेकंड          | \~900      |
| RTX 4090 24GB | 24GB | \~3 सेकंड          | \~1200     |
| A100 40GB     | 40GB | \~2 सेकंड          | \~1800     |

### schnell बनाम dev का उपयोग कब करें

**FLUX.1-schnell का उपयोग करें जब:**

* तेज़ प्रोटोटाइपिंग / प्रॉम्प्ट्स का परीक्षण
* उच्च मात्रा में बैच जनरेशन
* वाणिज्यिक प्रोजेक्ट (Apache 2.0)
* सीमित GPU बजट
* रीयल-टाइम या रीयल-टाइम के करीब अनुप्रयोग

**FLUX.1-dev का उपयोग करें जब:**

* अधिकतम छवि गुणवत्ता प्राथमिकता हो
* सूक्ष्म विवरण और जटिल दृश्य
* अनुसंधान / कलात्मक कार्य
* LoRA/ControlNet के साथ संयोजन (dev आमतौर पर बेहतर प्रतिक्रिया देता है)

***

## अगले चरण

* [ComfyUI](/guides/guides_v2-hi/image-generation/comfyui.md) - FLUX के लिए सबसे अच्छा इंटरफ़ेस
* [Fooocus](/guides/guides_v2-hi/image-generation/fooocus-simple-sd.md) - सरल विकल्प
* [ControlNet](/guides/guides_v2-hi/image-processing/controlnet-advanced.md) - निर्देशित जनरेशन
* [Kohya Training](/guides/guides_v2-hi/training/kohya-training.md) - FLUX LoRAs को प्रशिक्षित करें


---

# 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/image-generation/flux.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.