FLUX.1

Clore.ai पर Black Forest Labs के FLUX.1 इमेज जनरेशन चलाएँ

तेज़ विकल्प! FLUX.2 Klein तुलनीय गुणवत्ता के साथ < 0.5 सेकंड में छवियाँ उत्पन्न करता है (FLUX.1 के लिए 10–30s के मुकाबले). यह मार्गदर्शिका LoRA प्रशिक्षण और ControlNet वर्कफ़्लो के लिए अभी भी प्रासंगिक है।

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

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

क्यों 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

सबसे आसान तैनाती के लिए, उपयोग करें ComfyUI with FLUX नोड्स.

स्थापना विधियाँ

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

# 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

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(
    "A cat wearing a space suit on Mars",
    num_inference_steps=4,
    guidance_scale=0.0,
).images[0]

image.save("flux_output.png")
PYEOF

विधि 3: Fooocus

Fooocus में निर्मित FLUX समर्थन है:

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 टेक्स्ट एन्कोड → आपका प्रॉम्प्ट

4. Empty SD3 Latent Image → आयाम सेट करें

5. KSampler → steps: 4, cfg: 1.0

6. VAE डीकोड → ae.safetensors

7. इमेज सेव करें

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

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

• स्टेप्स: 20-50

• CFG: 3.5

• प्रॉम्प्ट में guidance_scale का उपयोग करें

Python API

मूल जनरेशन

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="A serene Japanese garden with cherry blossoms",
    height=1024,
    width=1024,
    num_inference_steps=4,
    guidance_scale=0.0,
).images[0]

image.save("output.png")

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

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(
    "Portrait of a cyberpunk samurai",
    height=1024,
    width=1024,
    num_inference_steps=4,
).images[0]

बैच जनरेशन

prompts = [
    "A sunset over mountains",
    "A futuristic city at night",
    "An underwater coral reef",
]

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 (उच्चतर गुणवत्ता)

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="Hyperrealistic portrait of an elderly fisherman",
    height=1024,
    width=1024,
    num_inference_steps=50,
    guidance_scale=3.5,
).images[0]

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

FLUX में बेहतर है:

• छवियों में टेक्स्ट: "A neon sign that says 'OPEN 24/7'"

• जटिल दृश्य: "A busy Tokyo street at night with reflections"

• विशेष शैलियाँ: "Oil painting in the style of Monet"

• विस्तृत वर्णन: लंबा, विस्तृत प्रॉम्प्ट अच्छी तरह काम करते हैं

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

# फ़ोटो-यथार्थवादी
पतझड़ की पत्तियों में खेलते हुए एक गोल्डन रिट्रीवर पिल्ले की पेशेवर फ़ोटोग्राफ़, 
शैलो डेप्थ ऑफ फील्ड, गर्म दोपहर की रोशनी, Canon EOS R5

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

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

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

मेमोरी अनुकूलन

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

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 के लिए

क्वांटाइज़्ड वर्शन या ComfyUI के साथ GGUF का उपयोग करें:

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

# क्वांटाइज़्ड मॉडल डाउनलोड करें
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 ऑफलोड के साथ	8GB	12GB+
क्वांटाइज़्ड (GGUF)	6GB	8GB+

GPU प्रीसेट्स

RTX 3060 12GB (बजट)

# क्वांटाइज़्ड मॉडल का उपयोग करें
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 (उत्तम)

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 टाइलिंग सक्षम करें

RTX 4090 24GB (प्रदर्शन)

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 स्टेप
# - टाइलिंग के साथ 1536x1536 कर सकता है

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

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)

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

आउट ऑफ़ मेमोरी

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

# या क्रमिक 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 को फाइन-ट्यून करने की अनुमति देते हैं। HuggingFace और CivitAI पर सैकड़ों समुदाय LoRA उपलब्ध हैं।

इंस्टॉलेशन

pip install diffusers transformers accelerate peft

एकल LoRA लोड करना

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(
    "A portrait in the style of Van Gogh, swirling brushstrokes",
    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 से लोड करना

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 रिपो से लोड करें
pipe.load_lora_weights(
    "username/my-flux-lora",          # HF repo ID
    weight_name="my_lora.safetensors" # रिपो में फ़ाइलनाम
)

image = pipe(
    "trigger_word a beautiful landscape",
    num_inference_steps=20,
    guidance_scale=3.5,
).images[0]
image.save("output.png")

LoRA स्केल (शक्ति)

# cross_attention_kwargs के साथ LoRA प्रभाव नियंत्रित करें
image = pipe(
    "A cyberpunk character, neon lights",
    num_inference_steps=20,
    guidance_scale=3.5,
    cross_attention_kwargs={"scale": 0.8},  # 0.0 = कोई प्रभाव नहीं, 1.0 = पूरा प्रभाव
).images[0]

कई LoRA को मिलाना

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 wearing elaborate costume, artistic_trigger style",
    num_inference_steps=25,
    guidance_scale=3.5,
).images[0]
image.save("combined_lora.png")

LoRA अनलोड करना

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

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

# 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 FLUX जनरेशन को canny एजेस, डेप्थ मैप और पोज़ कंकाल जैसी संरचनात्मक इनपुट्स के साथ मार्गदर्शित करने की अनुमति देता है। XLabs-AI ने विशेष रूप से FLUX.1 के लिए पहले ControlNet मॉडल जारी किए हैं।

इंस्टॉलेशन

pip install diffusers transformers accelerate controlnet-aux pillow

FLUX ControlNet Canny (XLabs-AI)

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 वेरिएंट)
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 एजेस)
input_image = load_image("your_input.jpg").resize((1024, 1024))
canny = CannyDetector()
control_image = canny(input_image, low_threshold=50, high_threshold=200)

# ControlNet मार्गदर्शन के साथ जेनरेट करें
image = pipe(
    prompt="A futuristic cityscape with neon signs, photorealistic, 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

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 = hf_pipeline("depth-estimation", model="LiheYoung/depth-anything-small-hf")

# डेप्थ मैप तैयार करें
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="A marble statue of a warrior, dramatic lighting, museum photo",
    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")

Multi-ControlNet for FLUX

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="A knight in armor standing in a forest, dramatic lighting",
    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 मॉडल

मॉडल	रिपो	उपयोग का मामला
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 या सर्वोत्तम गुणवत्ता के लिए इसके गुणांक

• शैली + संरचना नियंत्रण के लिए LoRA के साथ मिलाएँ

• ControlNet के साथ आम तौर पर कम स्टेप्स (20–25) काफी होते हैं

---

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

FLUX.1-schnell FLUX का डिस्टिल्ड, स्पीड-ऑप्टिमाइज़्ड वेरिएंट है। यह मात्र 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 से अलग वाणिज्यिक लाइसेंस की आवश्यकता है।

त्वरित प्रारम्भ

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="A stunning aerial view of New York City at golden hour, photorealistic",
    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 सेकंड में जेनरेट किया गया!")

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

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 = [
    "A serene mountain lake at dawn, misty atmosphere",
    "A bustling Tokyo street market at night, neon reflections",
    "A macro photograph of a dew-covered spider web",
    "An ancient library with floating books and magical light",
    "A futuristic underwater city with bioluminescent sea life",
]

# बैच जनरेशन
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"Generated {i+1}/{len(prompts)}: {prompt[:50]}...")

schnell के साथ विभिन्न एस्पेक्ट रेशियो

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 लचीले एस्पेक्ट रेशियो का समर्थन करता है
resolutions = {
    "square":    (1024, 1024),
    "portrait":  (768,  1360),
    "landscape": (1360, 768),
    "tall":      (576,  1792),
    "wide":      (1792, 576),
}

prompt = "A majestic wolf in a snowy forest, professional wildlife photography"

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"Saved {name}: {width}x{height}")

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

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  # पुराने GPUs पर मेमोरी बचाने के लिए fp16
)
pipe.enable_model_cpu_offload()
pipe.enable_vae_slicing()
pipe.enable_vae_tiling()

image = pipe(
    prompt="A cozy cabin in autumn forest, warm light through windows",
    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 - FLUX के लिए सर्वश्रेष्ठ इंटरफ़ेस

• Fooocus - सरल विकल्प

• ControlNet - गाइडेड जनरेशन

• Kohya प्रशिक्षण - FLUX LoRAs को ट्रेन करें