अपने हार्डवेयर पर Flux 2 चलाने का मतलब है कोई रेट लिमिट नहीं, कोई फ़ीस नहीं, और हर पैरामीटर पर पूरा नियंत्रण। यह लेख दो इंस्टॉलेशन तरीके समझाता है: बिना कोड वाले विज़ुअल वर्कफ़्लो के लिए ComfyUI, और स्क्रिप्ट से नियंत्रण के लिए Hugging Face Diffusers। साथ में 8 GB कार्ड के लिए VRAM ऑप्टिमाइज़ेशन और यह भी कि बिना किसी लोकल सेटअप के Flux 2 Pro तक कैसे पहुँचें।
अपनी मशीन पर सीधे एक अत्याधुनिक टेक्स्ट-टू-इमेज मॉडल चलाना आपके काम करने का तरीका पूरी तरह बदल देता है। कोई उपयोग सीमा नहीं, कोई कतार नहीं, और हर प्रयोग पर सब्सक्रिप्शन फ़ीस का बोझ नहीं। Black Forest Labs का Flux 2 आज उपलब्ध सबसे सक्षम ओपन-वेट इमेज जनरेशन मॉडल में से एक है, और इसे लोकली इंस्टॉल करना ज़्यादातर लोगों की उम्मीद से कहीं ज़्यादा आसान है। यह लेख सिस्टम की ज़रूरतों से लेकर आपकी पहली जनरेट की गई इमेज तक पूरी प्रक्रिया बताता है।
Flux 2, Flux आर्किटेक्चर की दूसरी पीढ़ी है, जिसे Black Forest Labs ने बनाया है, वही टीम जो आज उपलब्ध कुछ सबसे फ़ोटोरियलिस्टिक ओपन-वेट मॉडलों के पीछे है। यह मूल Flux.1 परिवार पर आधारित है और इसमें बेहतर प्रॉम्प्ट अनुपालन, इंसानी सब्जेक्ट्स में बेहतर शारीरिक सटीकता, और मानक रिज़ॉल्यूशन पर तेज़ डिटेल रेंडरिंग है। यह मॉडल ट्रांसफ़ॉर्मर-आधारित डिफ़्यूज़न आर्किटेक्चर इस्तेमाल करता है, जो पुराने Stable Diffusion मॉडलों में मिलने वाले U-Net डिज़ाइन से मूल रूप से अलग है।
Flux 2 परिवार कई अलग-अलग वर्ज़न में आता है, और हर एक अलग हार्डवेयर स्तर और इस्तेमाल के लिए बना है:
| मॉडल | ज़रूरी VRAM | सबसे अच्छा किसके लिए |
|---|---|---|
| flux-2-dev | 16–24 GB | रिसर्च, फाइन-ट्यूनिंग, लोकल काम |
| flux-2-pro | केवल क्लाउड | कमर्शियल प्रोडक्शन उपयोग |
| flux-2-max | केवल क्लाउड | अधिकतम डिटेल और रिज़ॉल्यूशन |
| flux-2-flex | केवल क्लाउड | लचीला आस्पेक्ट रेशियो नियंत्रण |
| flux-2-klein-4b | 8–12 GB | आम कंज़्यूमर हार्डवेयर पर तेज़ इनफ़रेंस |
| flux-2-klein-9b-base | 16 GB | हाई फ़िडेलिटी लोकल जनरेशन |
लोकल इंस्टॉलेशन के लिए, flux-2-dev और flux-2-klein-4b आपके मुख्य लक्ष्य हैं। Pro, Max और Flex वर्ज़न केवल API के ज़रिए चलते हैं और इन्हें डाउनलोड करने योग्य वेट्स के रूप में नहीं बाँटा जाता।
लागत बचाने से परे भी ठोस कारण हैं। लोकल इनफ़रेंस का मतलब है कि आपके प्रॉम्प्ट और जनरेट की गई इमेज कभी आपकी मशीन से बाहर नहीं जातीं, जो संवेदनशील विषयों वाले कमर्शियल काम में मायने रखता है। हर सैंपलिंग पैरामीटर पर आपका सीधा नियंत्रण रहता है। आप रात भर में सैकड़ों इमेज बैच में प्रोसेस कर सकते हैं, बिना हर जनरेशन की कीमत की चिंता किए। और कस्टम डेटासेट पर फाइन-ट्यूनिंग या LoRA अडैप्टर जोड़ने के लिए लोकल इंस्टॉलेशन ही एकमात्र व्यावहारिक रास्ता है।
कुछ भी डाउनलोड करने से पहले, अपने हार्डवेयर और सॉफ़्टवेयर स्टैक को इन ज़रूरतों से मिलाकर देख लें। बेमेल डिपेंडेंसी ही ज़्यादातर आम इंस्टॉलेशन विफलताओं की वजह होती हैं।
Flux 2 को चलाने के लिए काफ़ी ज़्यादा कंप्यूटिंग संसाधन चाहिए। यहाँ साफ़-साफ़ तस्वीर है:
न्यूनतम व्यावहारिक सेटअप:
अनुशंसित सेटअप:
AMD GPU Linux पर ROCm के ज़रिए काम करते हैं, लेकिन Windows पर ड्राइवर सपोर्ट असंगत है। CUDA सेटअप की तुलना में आपको ज़्यादा ट्रबलशूटिंग की उम्मीद रखनी चाहिए।
Apple Silicon (M1/M2/M3/M4) MLX फ़्रेमवर्क के ज़रिए क्वांटाइज़्ड Flux 2 वर्ज़न चला सकता है। जेनरेशन का समय तुलनीय NVIDIA कार्ड से 2–4 गुना धीमा होता है, लेकिन इमेज क्वालिटी बराबर होती है।
💡 टिप: अगर आपके GPU में ठीक 8 GB VRAM है, तो GGUF Q4_K_S क्वांटाइज़ेशन इस्तेमाल करें। क्वालिटी थोड़ी गिरती है, लेकिन ज़्यादातर प्रॉम्प्ट पर मॉडल बिना मेमोरी एरर के चलता है।
किसी भी Python पैकेज इंस्टॉलेशन के सही ढंग से काम करने से पहले आपका सॉफ़्टवेयर स्टैक मेल खाना चाहिए:
nvidia-smi से जाँचें।Windows पर CUDA को NVIDIA डेवलपर पोर्टल से इंस्टॉल करें। Ubuntu 22.04 या उसके बाद के वर्ज़न पर, runfile इंस्टॉलर पहले से इंस्टॉल ड्राइवरों के साथ पैकेज टकराव से बचाता है।
Flux 2 को लोकली चलाने के लिए दो अच्छी तरह समर्थित तरीके मौजूद हैं। इनमें से कोई भी वस्तुनिष्ठ रूप से बेहतर नहीं है, और सही चुनाव पूरी तरह इस पर निर्भर करता है कि आप कैसे काम करते हैं।
ComfyUI डिफ़्यूज़न मॉडल चलाने के लिए एक नोड-आधारित ग्राफ़िकल इंटरफ़ेस है। आप जेनरेशन पाइपलाइन बनाने के लिए विज़ुअल कैनवास पर नोड जोड़ते हैं। शुरुआती सेटअप के बाद किसी Python स्क्रिप्टिंग की ज़रूरत नहीं होती। ज़्यादातर लोगों के लिए यह शून्य से काम करने वाले Flux 2 इंस्टॉलेशन तक का सबसे तेज़ रास्ता है।
ComfyUI चुनें जब:
diffusers लाइब्रेरी डिफ़्यूज़न मॉडल को प्रोग्रामेटिक रूप से चलाने के लिए स्टैंडर्ड Python API है। आप इनफ़रेंस स्क्रिप्ट लिखते हैं और प्रिसिशन dtype से लेकर कस्टम शेड्यूलर तक हर पैरामीटर पर आपका पूरा नियंत्रण होता है।
Diffusers चुनें जब:
बिना कोड लिखे जल्दी काम करने वाले नतीजे चाहने वाले ज़्यादातर उपयोगकर्ताओं के लिए यह अनुशंसित रास्ता है।
स्टेप 1: ComfyUI रिपॉज़िटरी क्लोन करें और डायरेक्टरी में जाएँ:
git clone https://github.com/comfyanonymous/ComfyUI
cd ComfyUI
स्टेप 2: CUDA सपोर्ट के साथ PyTorch इंस्टॉल करें। अपने CUDA वर्ज़न के लिए सही कमांड पाने हेतु pytorch.org का सिलेक्टर इस्तेमाल करें। CUDA 12.1 के लिए:
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
स्टेप 3: ComfyUI की बाकी डिपेंडेंसी इंस्टॉल करें:
pip install -r requirements.txt
स्टेप 4: सर्वर लॉन्च करें:
python main.py --gpu-only
अपने ब्राउज़र में http://127.0.0.1:8188 खोलें। ComfyUI अब चल रहा है।
💡 टिप: Windows पर, ComfyUI के आधिकारिक GitHub पेज से पोर्टेबल स्टैंडअलोन रिलीज़ में Python और PyTorch पहले से इंस्टॉल होते हैं। यह एक डबल-क्लिक से शुरू होता है और ज़्यादातर एनवायरनमेंट सेटअप की समस्याओं से पूरी तरह बचाता है।
Flux 2 के वेट्स Hugging Face पर होस्ट होते हैं। आपको एक मुफ़्त अकाउंट चाहिए और डाउनलोड सफल होने से पहले मॉडल पेज पर लाइसेंस समझौता स्वीकार करना होगा।
flux-2-dev के लिए (16 GB+ VRAM चाहिए):
huggingface-cli download black-forest-labs/FLUX.2-dev \
flux2-dev.safetensors \
--local-dir ./models/checkpoints/
flux-2-klein-4b के लिए (8 GB कार्ड पर चलता है):
huggingface-cli download black-forest-labs/FLUX.2-klein-4b \
--local-dir ./models/checkpoints/
आपको साझा टेक्स्ट एनकोडर और VAE की भी ज़रूरत है। ये कंपोनेंट सभी Flux वर्ज़न में दोबारा इस्तेमाल होते हैं:
# T5 text encoder in fp8 (saves approximately 8 GB VRAM vs full precision)
huggingface-cli download comfyanonymous/flux_text_encoders \
t5xxl_fp8_e4m3fn.safetensors \
--local-dir ./models/clip/
# CLIP text encoder
huggingface-cli download openai/clip-vit-large-patch14 \
--local-dir ./models/clip/
# VAE (shared from Flux.1)
huggingface-cli download black-forest-labs/FLUX.1-schnell \
ae.safetensors \
--local-dir ./models/vae/
ComfyUI में Load बटन के ज़रिए आधिकारिक Flux वर्कफ़्लो JSON लोड करें। कॉन्फ़िगर करने वाले मुख्य नोड ये हैं:
Queue Prompt दबाएँ और आपकी पहली Flux 2 जनरेशन शुरू हो जाएगी।
स्क्रिप्ट-आधारित वर्कफ़्लो और एप्लिकेशन डेवलपमेंट के लिए, Hugging Face की diffusers लाइब्रेरी इमेज जनरेशन के हर पहलू पर सबसे ज़्यादा नियंत्रण देती है।
प्रोजेक्ट्स के बीच पैकेज टकराव रोकने के लिए AI प्रोजेक्ट्स को हमेशा वर्चुअल एनवायरनमेंट में अलग रखें।
python -m venv flux2-env
# Windows activation
flux2-env\Scripts\activate
# Linux and macOS activation
source flux2-env/bin/activate
pip install --upgrade pip
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu121
pip install diffusers transformers accelerate sentencepiece protobuf
pip install huggingface_hub
कम VRAM वाले कार्ड पर GGUF क्वांटाइज़ेशन सपोर्ट के लिए:
pip install gguf
💡 टिप: एक सफल इंस्टॉल के बाद, अपने वर्ज़न पिन करने के लिए
pip freeze > requirements.txtचलाएँ।diffusersलाइब्रेरी बार-बार अपडेट होती है और कभी-कभी ब्रेकिंग बदलाव Flux पाइपलाइन API को प्रभावित करते हैं।
flux-2-dev के लिए एक न्यूनतम काम करने वाली स्क्रिप्ट:
import torch
from diffusers import FluxPipeline
pipe = FluxPipeline.from_pretrained(
"black-forest-labs/FLUX.2-dev",
torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()
prompt = "A photorealistic portrait of a woman in soft natural light, film grain, 8K"
image = pipe(
prompt,
height=1024,
width=1024,
guidance_scale=3.5,
num_inference_steps=28,
max_sequence_length=512,
generator=torch.Generator("cpu").manual_seed(42)
).images[0]
image.save("flux2_output.png")
इसे इस तरह चलाएँ:
python generate.py
पहली बार चलाने पर लगभग 24 GB मॉडल वेट्स डाउनलोड होते हैं। इसके बाद के रन एक आधुनिक NVMe SSD पर लगभग 30 सेकंड में कैश से लोड हो जाते हैं।
हर किसी के पास 24 GB GPU नहीं होता। ये दो रणनीतियाँ आपको 8–12 GB कार्ड पर Flux 2 चलाने देती हैं, बिना उस मूल इमेज क्वालिटी को खोए जो इस मॉडल को उपयोगी बनाती है।
GGUF एक क्वांटाइज़ेशन फ़ॉर्मैट है, जो llama.cpp इकोसिस्टम से अपनाया गया है और अब इमेज डिफ़्यूज़न मॉडलों के साथ काम करता है। यह मॉडल की प्रिसिशन को 16-bit फ़्लोट से घटाकर 4-bit या 8-bit इंटीजर कर देता है, जिससे VRAM की ज़रूरत 50–75% तक कम हो जाती है।
Flux 2 के लिए कम्युनिटी-क्वांटाइज़्ड GGUF फ़ाइलें Hugging Face पर उपलब्ध हैं। हर क्वांटाइज़ेशन स्तर पर व्यावहारिक समझौता:
| फ़ाइल | VRAM उपयोग | क्वालिटी |
|---|---|---|
| flux2-dev-Q8_0.gguf | ~10 GB | लगभग लॉसलेस |
| flux2-dev-Q4_K_S.gguf | ~6 GB | अच्छी, हल्की नरमी |
| flux2-dev-Q3_K_M.gguf | ~5 GB | त्वरित परीक्षणों के लिए स्वीकार्य |
ComfyUI में, ComfyUI-GGUF कस्टम नोड एक्सटेंशन इंस्टॉल करें, फिर .gguf चेकपॉइंट फ़ाइल लोड करें, ठीक वैसे ही जैसे आप कोई भी .safetensors चेकपॉइंट लोड करते हैं। किसी और वर्कफ़्लो बदलाव की ज़रूरत नहीं है।
दो अतिरिक्त मेमोरी कटौती रणनीतियाँ जो एक साथ अच्छी तरह काम करती हैं:
Diffusers में fp8 ट्रांसफ़ॉर्मर लोडिंग:
from diffusers import FluxPipeline, FluxTransformer2DModel
import torch
transformer = FluxTransformer2DModel.from_pretrained(
"black-forest-labs/FLUX.2-dev",
subfolder="transformer",
torch_dtype=torch.float8_e4m3fn
)
pipe = FluxPipeline.from_pretrained(
"black-forest-labs/FLUX.2-dev",
transformer=transformer,
torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()
सीक्वेंशियल CPU ऑफ़लोडिंग (धीमी, लेकिन 8 GB कार्ड पर चलती है):
pipe.enable_sequential_cpu_offload()
💡 टिप: 8 GB कार्ड पर सबसे अच्छे संतुलन के लिए GGUF Q4_K_S को
enable_model_cpu_offload()के साथ मिलाएँ। हर 1024x1024 इमेज के लिए 3–5 मिनट के जेनरेशन समय की उम्मीद रखें, जो निजी, बार-बार बदलाव वाले काम के लिए पूरी तरह व्यावहारिक है।
अगर आप पूरे लोकल सेटअप में उतरने से पहले Flux 2 आज़माना चाहते हैं, या आपको केवल क्लाउड वाले Pro और Max वर्ज़न तक पहुँच चाहिए, तो PicassoIA सभी Flux 2 मॉडल सीधे ब्राउज़र में देता है, बिना किसी इंस्टॉलेशन के।
flux-2-pro और flux-2-max डाउनलोड करने योग्य वेट्स के रूप में उपलब्ध नहीं हैं। ये केवल क्लाउड API के ज़रिए चलते हैं। PicassoIA दोनों तक ब्राउज़र से पहुँच देता है, साथ ही लचीले आउटपुट आयामों के लिए flux-2-flex और तेज़ जनरेशन के लिए flux-2-klein-4b भी।
PicassoIA पर Flux 2 से जनरेट करने के चरण:
24 GB GPU पर लोकली flux-2-dev चलाने जैसी क्वालिटी के लिए, PicassoIA पर लागू वर्ज़न शून्य सेटअप समय में बराबर परिणाम देता है।
Flux 2 प्राकृतिक भाषा के प्रॉम्प्ट पर अच्छी प्रतिक्रिया देता है। आपको वेटेड ब्रैकेट या टोकन स्टैकिंग की ज़रूरत नहीं है। जो चाहिए, उसे एक साफ़ और विशिष्ट वाक्य में लिखें।
क्या अच्छा काम करता है:
किससे बचें:
💡 टिप: flux-2-klein-4b के लिए, गाइडेंस स्केल 2.5 और 4.0 के बीच रखें। ज़्यादा मान छोटे मॉडल पर रंगों को ओवरसैचुरेट कर देते हैं।
चाहे आपने ComfyUI का रास्ता अपनाया हो, Diffusers स्क्रिप्ट लिखी हो, या PicassoIA पर flux-2-pro खोला हो, अब Flux 2 के साथ काम करने के लिए आपके पास ज़रूरी सब कुछ है।
Flux 2 को लोकली चलाने, या PicassoIA जैसे प्लेटफ़ॉर्म के ज़रिए इस्तेमाल करने का असली फ़ायदा इटरेशन की रफ़्तार है। एक प्रॉम्प्ट लिखें, एक मिनट से कम में नतीजा देखें, विवरण को परिष्कृत करें और फिर से जनरेट करें। यही तेज़ फ़ीडबैक लूप है जिसमें प्रॉम्प्ट लिखने और पैरामीटर ट्यूनिंग का असली कौशल विकसित होता है।
PicassoIA आपको flux-2-dev, flux-2-pro, flux-2-max, flux-2-flex और कुशल flux-2-klein-4b तक तुरंत पहुँच देता है, बिना CUDA कॉन्फ़िगरेशन, बिना 24 GB वेट डाउनलोड और बिना वर्चुअल एनवायरनमेंट सेटअप के। यह तय करने से पहले कि आपके वर्कफ़्लो के लिए पूरा लोकल इंस्टॉलेशन लायक है या नहीं, हर वर्ज़न वास्तव में क्या देता है, यह बेंचमार्क करने का सबसे तेज़ तरीका है।
ऐसे प्रॉम्प्ट से शुरू करें जो आपके लिए मायने रखता हो। उसे flux-2-dev पर चलाएँ, फिर उसकी तुलना flux-2-klein-4b से करें। दोनों के बीच जो बदलता है, उसे नोट करें। वह तुलना आपको बिना किसी अनुमान के बताएगी कि आपके खास इस्तेमाल के लिए कौन-सा हार्डवेयर निवेश सही है।
अपनी भाषा चुनें
