FLUX.1

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

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

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

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

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 (अनुशंसित)

# 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(
    "मंगल ग्रह पर स्पेस सूट पहने एक बिल्ली",
    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 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

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

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")

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

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]

बैच जनरेशन

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

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

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 का उपयोग करें:

# 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 (बजट)

# 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 (इष्टतम)

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 (प्रदर्शन)

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 (प्रोडक्शन)

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

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

# 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 उपलब्ध हैं।

स्थापना

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(
    "वैन गॉग की शैली में एक पोर्ट्रेट, घूमते हुए ब्रशस्ट्रोक",
    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 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 स्केल (ताकत)

# 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 को मिलाना

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 अनलोड करना

# बेस मॉडल को पुनर्स्थापित करने के लिए 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, canny edges, depth maps, और pose skeletons जैसे संरचनात्मक इनपुट के साथ FLUX जनरेशन को मार्गदर्शन करने देता है। 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 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

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

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 से अलग व्यावसायिक लाइसेंस चाहिए।

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

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 सेकंड में जनरेट हुआ!")

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

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

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

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 - FLUX के लिए सबसे अच्छा इंटरफ़ेस

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

• ControlNet - निर्देशित जनरेशन

• Kohya Training - FLUX LoRAs को प्रशिक्षित करें