RTX 3090 पर FLUX.2 को लोकल रूप से कैसे चलाएँ

इस ट्यूटोरियल में, हम सीखेंगे कि FLUX.2 इमेज जनरेशन मॉडल को लोकल रूप से कैसे चलाया जाए। हम GPU वातावरण सेट करेंगे, FLUX.2 का एक क्वांटाइज़्ड संस्करण डाउनलोड करेंगे, उसे कुशलतापूर्वक GPU और RAM मेमोरी में लोड करेंगे, इन्फेरेंस चलाएँगे, और फिर अलग-अलग कॉन्फ़िगरेशन विकल्पों के साथ प्रयोग करेंगे।

RTX 3090 पर इस आकार के मॉडल को चलाना चुनौतीपूर्ण हो सकता है, और यह ट्यूटोरियल बिना अनावश्यक जटिलता के FLUX.2 को लोकल रूप से काम कराने का सबसे सरल, व्यावहारिक तरीका बताता है।

यदि आप मॉडल मैनेजमेंट और ऑप्टिमाइज़ेशन की उन्नत तकनीकों—जैसे प्रूनिंग, क्वांटाइज़ेशन और लॉगिंग—में रुचि रखते हैं, तो मैं Scalable AI Models with PyTorch Lightning कोर्स लेने की सलाह देता/देती हूँ। 

FLUX.2 क्या है?

FLUX.2 एक इमेज जनरेशन मॉडल है जो वास्तविक क्रिएटिव काम के लिए बनाया गया है, केवल प्रयोगों के लिए नहीं। यह उच्च-गुणवत्ता, यथार्थपरक इमेज बनाता है और कई रेफरेंस इमेज के बीच कैरेक्टर्स, स्टाइल्स और प्रोडक्ट्स को सुसंगत रखता है। मूल FLUX मॉडल पर आधारित, यह प्रॉम्प्ट्स को सटीकता से फॉलो करता है, टेक्स्ट को स्पष्ट रूप से रेंडर करता है, और लाइटिंग, लेआउट्स और ब्रांडिंग को अच्छी तरह संभालता है। 

FLUX.2 हाई-रेज़ोल्यूशन इमेज एडिटिंग को भी सपोर्ट करता है और रेडी-टू-यूज़ APIs तथा ओपन मॉडल्स—जिन्हें आप लोकल रूप से चला सकते हैं—दोनों रूपों में उपलब्ध है, जिससे यह व्यावहारिक, लचीला और वास्तविक प्रोडक्शन वर्कफ़्लोज़ में फिट करना आसान हो जाता है।

FLUX.2 चार मुख्य वेरिएंट्स में आता है: 

• FLUX.2 [max]
• FLUX.2 [pro]
• FLUX.2 [flex]
• FLUX.2 [dev]

प्रत्येक को नियंत्रण, प्रदर्शन और डिप्लॉयमेंट आवश्यकताओं के अलग-अलग स्तरों के लिए डिज़ाइन किया गया है। 

व्यापक लीडरबोर्ड तुलना में, FLUX.2 के तीनों वेरिएंट Artificial Analysis लीडरबोर्ड पर शीर्ष 10 इमेज एडिटिंग मॉडलों में आते हैं, जहाँ FLUX.2 [max] और FLUX.2 [pro] ने GPT-5 और पिछले जेनरेशन के FLUX.1 Kontext वेरिएंट्स जैसे मॉडलों से बेहतर प्रदर्शन किया है।

स्रोत: Text to Image Leaderboard | Artificial Analysis

FLUX.2 को लोकल रूप से चलाना: चरण-दर-चरण मार्गदर्शक

नीचे दिए गए चरणों में, मैं RTX 3090 GPU का उपयोग करके FLUX.2 को लोकल रूप से चलाने के लिए आपको सब कुछ समझाऊँगा/समझाऊँगी। 

1. सिस्टम आवश्यकताएँ और पूर्वापेक्षाएँ

FLUX.2 को लोकल रूप से चलाने से पहले, सुनिश्चित करें कि आपका सिस्टम GPU इन्फेरेंस के लिए सही ढंग से सेट है।

हार्डवेयर

• NVIDIA GPU (RTX 3090 अनुशंसित)
• 24 GB VRAM
• 64 GB सिस्टम RAM अनुशंसित

NVIDIA ड्राइवर्स और CUDA टूलकिट

• NVIDIA ड्राइवर्स इंस्टॉल करें: सुनिश्चित करें कि हालिया CUDA वर्ज़न (CUDA 12.1+ अनुशंसित) को सपोर्ट करने वाले नवीनतम NVIDIA GPU ड्राइवर्स इंस्टॉल हैं।
• CUDA टूलकिट इंस्टॉल करें: आधिकारिक NVIDIA CUDA Downloads पेज से CUDA टूलकिट डाउनलोड और इंस्टॉल करें ताकि GPU एक्सटेंशन्स और कस्टम कर्नेल्स के साथ कम्पैटिबिलिटी बेहतर हो।

इंस्टॉलेशन वेरिफाई करने के लिए टर्मिनल में निम्न कमांड चलाएँ:

nvidia-smiसंचालित द्वारा

जैसा कि हम देख सकते हैं, हमारे पास CUDA वर्ज़न 13 के साथ RTX 3090 GPU है। 

Python और Jupyter

• Python 3.10+
• Jupyter Notebook या JupyterLab (आसान, इंटरैक्टिव प्रयोग के लिए अनुशंसित)

pip install jupyterlab notebookसंचालित द्वारा

नोट: हम अपने कोडिंग वातावरण के रूप में Jupyter Notebook का उपयोग कर रहे हैं, जो प्रयोग करना, क्रमबद्ध तरीके से इन्फेरेंस चलाना, और नोटबुक के अंदर ही इमेज जनरेट और एडिट करना आसान बनाता है।

2. CUDA सपोर्ट के साथ PyTorch इंस्टॉल करना

इस चरण में, हम CUDA सपोर्ट के साथ PyTorch इंस्टॉल करते हैं ताकि इन्फेरेंस CPU के बजाय GPU पर चले। नीचे दिया गया कमांड PyTorch, TorchVision, और TorchAudio को प्रीकम्पाइल्ड CUDA बाइनरीज़ के साथ इंस्टॉल करता है, जिससे CUDA को सोर्स से बिल्ड करने की ज़रूरत नहीं रहती।

!pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu130संचालित द्वारा

इंस्टॉलेशन के बाद, यदि GPU उपलब्ध और सही तरह से कॉन्फ़िगर है, तो PyTorch अपने आप GPU का उपयोग करेगा।

3. FLUX.2 और आवश्यक डिपेंडेंसीज़ इंस्टॉल करना

इसके बाद, हम वे कोर लाइब्रेरीज़ इंस्टॉल करते हैं जो FLUX.2 को लोकल रूप से चलाने के लिए आवश्यक हैं। ये पैकेज मॉडल लोडिंग, इन्फेरेंस, GPU एक्सेलेरेशन, क्वांटाइज़ेशन, और कुशल डेटा ट्रांसफ़र को संभालते हैं।

!pip install -q diffusers transformers accelerate bitsandbytes huggingface_hub protobuf sentencepiece hf_transferसंचालित द्वारा

इंस्टॉलेशन होने के बाद, आपका वातावरण FLUX.2 लोड करने और इमेज जनरेशन व एडिटिंग इन्फेरेंस चलाने के लिए तैयार है।

4. GPU और क्वांटाइज़ेशन सपोर्ट को वेरिफाई करना

FLUX.2 लोड करने से पहले, हम वेरिफाई करते हैं कि PyTorch GPU देख पा रहा है और 4-बिट क्वांटाइज़ेशन सपोर्टेड है। यह चरण महत्वपूर्ण है ताकि मॉडल RTX 3090 की मेमोरी सीमाओं के भीतर कुशलता से चल सके।

import torch
import bitsandbytes as bnb

print(f"PyTorch Version: {torch.__version__}")
print(f"CUDA Version: {torch.version.cuda}")
print(f"Is CUDA available? {torch.cuda.is_available()}")
print(f"GPU Name: {torch.cuda.get_device_name(0)}")

# Check if 4-bit quantization is supported (Ampere 3090 supports this natively)
try:
    print(f"BitsAndBytes Version: {bnb.__version__}")
    print("4-bit quantization check: PASSED")
except ImportError:
    print("BitsAndBytes not installed correctly.")संचालित द्वारा

आउटपुट पुष्टि करता है कि PyTorch CUDA सपोर्ट के साथ सही इंस्टॉल है, आपका RTX 3090 GPU डिटेक्ट हो रहा है, और bitsandbytes 4-बिट क्वांटाइज़ेशन के साथ ठीक से काम कर रहा है, तो सिस्टम कुशल GPU इन्फेरेंस के लिए तैयार है।

PyTorch Version: 2.8.0+cu128
CUDA Version: 12.8
Is CUDA available? True
GPU Name: NVIDIA GeForce RTX 3090
BitsAndBytes Version: 0.49.0
4-bit quantization check: PASSEDसंचालित द्वारा

5. 4-बिट क्वांटाइज़ेशन के साथ FLUX.2 लोड करना

इस चरण में, हम FLUX.2 [dev] को 4-बिट क्वांटाइज़्ड चेकपॉइंट का उपयोग करके लोड करते हैं ताकि GPU मेमोरी उपयोग कम रहे, जबकि इमेज क्वालिटी उच्च बनी रहे। RTX 3090 जैसे कंज़्यूमर GPU पर FLUX.2 जैसे बड़े मॉडल को चलाने के लिए यह आवश्यक है।

हम आवश्यक लाइब्रेरीज़ इम्पोर्ट करके और कुछ मुख्य सेटिंग्स तय करके शुरू करते हैं।

• repo_id 4-बिट FLUX.2 dev चेकपॉइंट की ओर इंगित करता है।
• device आपका GPU चुनता है (पहला CUDA डिवाइस)।
• torch_dtype इन्फेरेंस के दौरान उपयोग होने वाली कंप्यूट प्रिसिशन सेट करता है। bfloat16 आमतौर पर उपयोग होता है क्योंकि यह मेमोरी घटाता है और गति में सुधार कर सकता है, जबकि आउटपुट स्थिर रखता है।

import torch
from transformers import Mistral3ForConditionalGeneration
from diffusers import Flux2Pipeline, Flux2Transformer2DModel

repo_id = "diffusers/FLUX.2-dev-bnb-4bit"
device = "cuda:0"
torch_dtype = torch.bfloat16संचालित द्वारा

इसके बाद, हम FLUX.2 का इमेज ट्रांसफॉर्मर बैकबोन (मुख्य घटक जो इमेज लैटेंट्स जनरेट करता है) पहले CPU पर लोड करते हैं। इससे शुरुआती लोड के दौरान VRAM नहीं भरती और पाइपलाइन को ज़रूरत पड़ने पर ही मॉड्यूल्स को GPU पर ले जाने की अधिक लचीलापन मिलता है।

transformer = Flux2Transformer2DModel.from_pretrained(
  repo_id, subfolder="transformer", torch_dtype=torch_dtype, device_map="cpu"
)संचालित द्वारा

फिर हम टेक्स्ट एन्कोडर भी CPU पर लोड करते हैं। टेक्स्ट एन्कोडर आपके प्रॉम्प्ट को एम्बेडिंग्स में बदलता है जो इमेज जनरेशन को गाइड करते हैं। सेटअप के दौरान इसे CPU पर रखना जनरेशन प्रक्रिया के भारी हिस्सों के लिए GPU मेमोरी खाली रखने में मदद करता है।

text_encoder = Mistral3ForConditionalGeneration.from_pretrained(
  repo_id, subfolder="text_encoder", dtype=torch_dtype, device_map="cpu"
)संचालित द्वारा

अंत में, हम Diffusers पाइपलाइन को असेंबल करते हैं, जिसमें हमने लोड किया हुआ ट्रांसफॉर्मर और टेक्स्ट एन्कोडर इंजेक्ट करते हैं। 

यहाँ मुख्य पंक्ति है enable_model_cpu_offload(): यह ऑटोमैटिक CPU ↔ GPU ऑफ़लोडिंग चालू करता है, यानी पाइपलाइन मॉडल के हिस्सों को तभी GPU पर ले जाती है जब उनकी सक्रिय रूप से ज़रूरत हो, और बाद में उन्हें वापस CPU पर ले आती है। कंज़्यूमर GPUs पर बड़े मॉडलों को बिना डिवाइस प्लेसमेंट को मैन्युअल रूप से मैनेज किए चलाने के यह सबसे आसान तरीकों में से एक है।

pipe = Flux2Pipeline.from_pretrained(
  repo_id, transformer=transformer, text_encoder=text_encoder, torch_dtype=torch_dtype
)
pipe.enable_model_cpu_offload()संचालित द्वारा

6. अपना पहला टेक्स्ट-टू-इमेज जनरेशन चलाना

अब हम FLUX.2 का उपयोग करके अपनी पहली इमेज जनरेट करने के लिए तैयार हैं। चीज़ों को सरल रखने के लिए, हम एक सिंगल टेक्स्ट प्रॉम्प्ट से शुरू करते हैं जो लेडीबग की एक हाइपर-रियलिस्टिक मैक्रो फ़ोटोग्राफ़ का वर्णन करता है।

prompt = (
    "Realistic macro photo of a ladybug perched on the edge of a dew-covered rose petal, "
    "early morning mist, soft natural light, shallow depth of field, crisp detail, creamy bokeh."
)
संचालित द्वारा

इसके बाद, हम प्रॉम्प्ट को पाइपलाइन में पास करते हैं और इन्फेरेंस चलाते हैं।

• हम गति और इमेज क्वालिटी के संतुलन के लिए 28 इन्फेरेंस स्टेप्स का उपयोग करते हैं।
• गाइडेंस स्केल 4 परिणाम को स्वाभाविक रखता है, बिना प्रॉम्प्ट को अत्यधिक फोर्स किए।
• फिक्स्ड रैंडम सीड रिसर्ज़नशील (reproducible) परिणाम सुनिश्चित करता है।

image = pipe(
  prompt=prompt,
  generator=torch.Generator(device=device).manual_seed(42),
  num_inference_steps=28,
  guidance_scale=4,
).images[0]संचालित द्वारा

इन्फेरेंस के दौरान कितनी GPU मेमोरी उपयोग हो रही है यह मॉनिटर करने के लिए, एक टर्मिनल खोलें और चलाएँ:

nvidia-smiसंचालित द्वारा

आपको लगभग 21 GB GPU VRAM उपयोग में दिखनी चाहिए और GPU उपयोगिता उच्च होनी चाहिए, जो दर्शाता है कि मॉडल उपलब्ध संसाधनों का कुशल उपयोग कर रहा है और RTX 3090 पर पूर्ण प्रदर्शन पर चल रहा है।

इन्फेरेंस पूरा होने के बाद, आप Jupyter Notebook के अंदर ही इमेज ऑब्जेक्ट को डिस्प्ले करके जनरेटेड इमेज देख सकते हैं:

imageसंचालित द्वारा

परिणाम अत्यधिक विस्तृत और यथार्थपरक है। मॉडल प्रॉम्प्ट को बारीकी से फॉलो करता है और साथ ही वे सूक्ष्म विवरण—जैसे लाइटिंग और टेक्स्चर—भी जोड़ता है जो स्पष्ट रूप से निर्दिष्ट नहीं थे।

अंत में, हम जनरेटेड इमेज को लोकली सेव करते हैं:

output_path = "flux2_local_full.png"
image.save(output_path)
print(f"Image saved to {output_path}")संचालित द्वारा

आउटपुट:

Image saved to flux2_local_full.pngसंचालित द्वारा

7. स्ट्रक्चर्ड JSON के साथ एडवांस्ड प्रॉम्प्टिंग

FLUX.2 ऐसी उन्नत प्रॉम्प्टिंग तकनीकों को सपोर्ट करता है जो साधारण टेक्स्ट से आगे जाती हैं, और अंतिम इमेज पर कहीं अधिक बारीक नियंत्रण देती हैं। स्ट्रक्चर्ड JSON प्रॉम्प्ट्स का उपयोग करके, आप सीन लेआउट, सब्जेक्ट्स, लाइटिंग, कैमरा सेटिंग्स, मूड, और यहाँ तक कि सटीक हेक्स कोड्स के साथ कलर पैलेट को स्पष्ट रूप से परिभाषित कर सकते हैं।

इस सेक्शन में, हम स्ट्रक्चर्ड JSON प्रॉम्प्ट का उपयोग करके सीन का विस्तार से वर्णन करते हैं। एक वाक्य के बजाय, हम वातावरण, सब्जेक्ट्स, स्टाइल, रंग, लाइटिंग, कैमरा प्रॉपर्टीज़, और नेगेटिव कंस्ट्रेंट्स को स्पष्ट और व्यवस्थित फ़ॉर्मैट में परिभाषित करते हैं। 

यह FLUX.2 को जटिल निर्देशों को बेहतर ढंग से समझने और अधिक पूर्वानुमेय, उच्च-गुणवत्ता वाले परिणाम देने में मदद करता है।

advanced_prompt = """
{
  "scene": "New Year's Eve night on a rooftop overlooking a glowing city skyline",
  "subjects": [
    {
      "description": "Group of close friends including men and women in winter clothing, natural facial proportions, diverse appearances",
      "position": "center and slightly spread across the frame",
      "action": "standing together in a loose circle, some smiling softly, others quietly reflective, sharing the moment before midnight"
    }
  ],
  "style": "Cinematic semi-realistic illustration with grounded realism, subtle painterly softness",
  "color_palette": ["#0B132B", "#1C2541", "#EAEAEA", "#F4D35E"],
  "lighting": "Soft moonlight as ambient key light, warm glow from sparklers and nearby string lights illuminating faces, gentle contrast",
  "mood": "Warm, intimate, reflective, hopeful",
  "background": "Out-of-focus city skyline with distant fireworks softly lighting the sky, minimal visual noise",
  "composition": "Wide medium shot, balanced framing, friends forming a natural arc, negative space above for sky and fireworks",
  "camera": {
    "angle": "eye-level",
    "lens": "50mm cinematic look",
    "depth_of_field": "sharp focus on group, gentle background blur"
  },
  "details": [
    "subtle breath vapor in cold air",
    "soft fabric textures on coats and scarves",
    "sparklers emitting warm golden particles",
    "natural body language and expressions",
    "no exaggerated poses or faces"
  ],
  "negative_prompt": [
    "cartoon style",
    "emote proportions",
    "chibi",
    "oversized heads",
    "text",
    "watermark",
    "logo",
    "overcrowded scene",
    "harsh neon lighting",
    "over-saturation",
    "extra limbs",
    "distorted faces"
  ]
}
"""संचालित द्वारा

फिर हम अधिक डिटेल कैप्चर करने के लिए स्टेप्स की संख्या बढ़ाकर इन्फेरेंस चलाते हैं, जबकि नैचुरल लुक के लिए गाइडेंस स्केल को मध्यम रखते हैं।

image_2 = pipe(
  prompt=advanced_prompt,
  generator=torch.Generator(device=device).manual_seed(42),
  num_inference_steps=50,
  guidance_scale=4,
).images[0]संचालित द्वारा

Jupyter Notebook के अंदर जनरेटेड इमेज डिस्प्ले करने के लिए:

image_2संचालित द्वारा

जनरेटेड इमेज स्ट्रक्चर्ड प्रॉम्प्ट का बारीकी से पालन करती है, सीन, मूड, लाइटिंग और कम्पोज़िशन को ठीक वैसा ही पकड़ती है जैसा निर्दिष्ट था। 

8. FLUX.2 के साथ इमेज एडिटिंग (इमेज टू इमेज)

FLUX.2 इमेज एडिटिंग को भी सपोर्ट करता है, जहाँ एक रेफरेंस इमेज को बेस के रूप में उपयोग किया जाता है और मॉडल टेक्स्ट प्रॉम्प्ट के आधार पर बदलाव लागू करता है। जब आप पहचान, चेहरे के फीचर्स और स्किन टोन को संरक्षित रखना चाहते हैं, और सब्जेक्ट के आसपास के सीन, मूड या वातावरण को बदलना चाहते हैं, तो यह विशेष रूप से उपयोगी है।

इस उदाहरण के लिए, हम रेफरेंस इमेज के रूप में Pexels.com से ली गई एक भारतीय महिला की फोटो का उपयोग करते हैं:

फोटो: cottonbro studio: https://www.pexels.com/photo/a-woman-with-a-nose-piercing-9317190/

हम सावधानी से प्रॉम्प्ट डिज़ाइन करते हैं ताकि मॉडल को महिला के चेहरे और प्राकृतिक स्किन टोन को यथावत रखने का निर्देश मिले, जबकि सेटिंग, लाइटिंग और भाव-भंगिमा बदली जाए। लक्ष्य है कि उसकी पहचान बदले बिना इमेज को एडिट किया जाए।

from diffusers.utils import load_image

prompt = (
    "Using the provided reference image, generate a realistic photograph of a woman with a similar face, "
    "standing at night and looking up at the sky with stars with a subtle, sad expression. "
    "Natural skin tones, soft moonlight, gentle shadows, shallow depth of field, "
    "with blurred city lights in the background."
)संचालित द्वारा

इसके बाद, हम रेफरेंस इमेज लोड करते हैं और उसे पाइपलाइन में पास करते हैं। FLUX.2 कई रेफरेंस इमेजेज़ को सपोर्ट करता है, लेकिन यहाँ हम एडिट को गाइड करने के लिए एक ही इमेज का उपयोग करते हैं।

indian_woman = load_image("https://images.pexels.com/photos/9317190/pexels-photo-9317190.jpeg")
image_3 = pipe(
    prompt=prompt,
    image=[indian_woman], 
    generator=torch.Generator(device=device).manual_seed(42),
    num_inference_steps=28,
    guidance_scale=4,
).images[0]संचालित द्वारा

Jupyter Notebook के अंदर एडिटेड परिणाम देखने के लिए:

image_3संचालित द्वारा

आउटपुट अत्यधिक यथार्थपरक है। मॉडल महिला की चेहरे की संरचना और स्किन टोन को संरक्षित रखते हुए उसे नई सेटिंग में अलग लाइटिंग, मूड और बैकग्राउंड के साथ स्वाभाविक रूप से रखता है। 

परिणाम AI एडिट की बजाय ऐसा लगता है मानो किसी प्रोफ़ेशनल फ़ोटोग्राफ़र ने किसी दूसरे स्थान और पल में फोटो ली हो।

FLUX.2 मेमोरी ऑप्टिमाइज़ेशन टिप्स

मेरे अनुभव में, 4-बिट क्वांटाइज़्ड मॉडल पर स्विच करने और Transformers व Diffusers के साथ कोड-फ़र्स्ट सेटअप अपनाने के बाद ही FLUX.2 को लोकल रूप से चलाना विश्वसनीय बना। 

इससे पहले, जब भी मैं बहुत कुछ सीधे CUDA पर लोड करने की कोशिश करता/करती, 24 GB RTX 3090 पर मुझे बार-बार आउट-ऑफ़-मेमोरी एरर मिलते थे। 

Stable Diffusion WebUI और ComfyUI जैसे UI टूल्स भी मेमोरी सीमाओं से जल्दी टकरा सकते हैं क्योंकि वे अक्सर अतिरिक्त इंटरमीडिएट बफ़र्स, प्रीव्यूज़ और वर्कफ़्लो स्टेट मेमोरी में रखते हैं—जब तक कि आप उनकी लो-VRAM ऑप्शंस को सावधानी से ट्यून न करें।

VRAM ऑप्टिमाइज़ेशन टिप्स (जिनसे मुझे वास्तविक मदद मिली):

• फुल-प्रिसिशन वेट्स के बजाय 4-बिट चेकपॉइंट (bitsandbytes) का उपयोग करें।
• कंपोनेंट्स को पहले CPU पर लोड करें (device_map="cpu") और सब कुछ upfront CUDA पर पुश करने से बचें।
• CPU–GPU ऑफ़लोडिंग सक्षम करें (pipe.enable_model_cpu_offload()), ताकि केवल सक्रिय हिस्से ही GPU पर रहें।
• इन्फेरेंस स्टेप्स को वाजिब रखें (उदाहरण के लिए, 28–35 स्टेप्स तेज़ रन के लिए; ज़रूरत पर ही बढ़ाएँ)।
• गाइडेंस स्केल मध्यम रखें (लगभग 3–5) ताकि अनावश्यक कंप्यूट और अस्थिरता से बचा जा सके।
• लाइव VRAM मॉनिटर करें nvidia-smi के साथ और अन्य GPU-हैवी ऐप्स बंद रखें।
• यदि फिर भी OOM हो, तो नोटबुक कर्नेल रीस्टार्ट करें ताकि GPU मेमोरी पूरी तरह क्लियर हो जाए और फिर दोबारा कोशिश करें।

यदि इन चरणों का पालन करने के बाद भी आप आउट-ऑफ़-मेमोरी समस्याओं का सामना कर रहे हैं, तो अतिरिक्त ट्रबलशूटिंग और मेमोरी ऑप्टिमाइज़ेशन उदाहरणों के लिए इस DataLab नोटबुक देखें।

अंतिम विचार

मैं वास्तव में प्रभावित हूँ कि ओपन-सोर्स इमेज जनरेशन मॉडल कितनी दूर आ चुके हैं। 

FLUX.2 जैसे मॉडल अब विज़ुअल क्वालिटी और प्रॉम्प्ट समझ—दोनों मामलों में—स्पष्ट रूप से मालिकाना सिस्टम्स के प्रतिस्पर्धी हैं। सही सेटअप, कुछ प्रयोग और थोड़ी-सी मेमोरी ऑप्टिमाइज़ेशन के साथ, कंज़्यूमर GPUs पर भी आप लोकल रूप से उच्च-गुणवत्ता, यथार्थपरक इमेज मुफ्त में जनरेट कर सकते हैं।

सबसे अलग जो बात दिखती है वह है नियंत्रण का स्तर। एडवांस्ड प्रॉम्प्टिंग, स्ट्रक्चर्ड JSON, मल्टी-रेफरेंस एडिटिंग और इमेज-टू-इमेज वर्कफ़्लोज़ आपको सरल जनरेशन से कहीं आगे जाने में सक्षम बनाते हैं। 

आप सिनेमैटिक सीन बना सकते हैं, स्टोरीटेलिंग के लिए इमेजेज़ विकसित कर सकते हैं, प्रोफ़ेशनल-ग्रेड इमेज एडिटिंग कर सकते हैं, और बंद प्लेटफ़ॉर्म्स पर निर्भर हुए बिना तेज़ी से इटरेट कर सकते हैं। 

क्रिएटर्स, रिसर्चर्स और डेवलपर्स के लिए, यह बहुत-सी क्रिएटिव स्वतंत्रता खोलता है और हाई-एंड इमेज जनरेशन को पहले से कहीं अधिक सुलभ बनाता है।