पाइथन में FLUX.1-dev GGUF Q8 चलाना

GGUF क्वांटाइजेशन के साथ FLUX.1-dev को तेज़ करें

Page content

FLUX.1-dev एक शक्तिशाली टेक्स्ट-टू-इमेज मॉडल है जो आश्चर्यजनक परिणाम उत्पन्न करता है, लेकिन इसकी 24GB+ मेमोरी आवश्यकता इसे कई सिस्टम पर चलाने में चुनौतीपूर्ण बनाती है। GGUF क्वांटाइजेशन के साथ FLUX.1-dev एक समाधान प्रदान करता है, जो मेमोरी उपयोग को लगभग 50% कम करता है जबकि उत्कृष्ट इमेज क्वालिटी बनाए रखता है।

उदाहरण आउटपुट Q8 क्वांटाइज्ड FLUX.1-dev - asic यह इमेज Q8 क्वांटाइज्ड FLUX.1-dev मॉडल के साथ GGUF फॉर्मेट का उपयोग करके उत्पन्न की गई है, जो कम मेमोरी फुटप्रिंट के बावजूद क्वालिटी को बनाए रखने का प्रदर्शन करता है।

GGUF क्वांटाइजेशन क्या है?

GGUF (GPT-Generated Unified Format) एक क्वांटाइजेशन फॉर्मेट है जो मूल रूप से भाषा मॉडल के लिए विकसित किया गया था लेकिन अब डिफ्यूजन मॉडल जैसे FLUX के लिए भी समर्थित है। क्वांटाइजेशन मॉडल का आकार कम करता है जो वेट्स को कम प्रिसिजन फॉर्मेट (8-बिट, 6-बिट, या 4-बिट) में स्टोर करके, पूर्ण 16-बिट या 32-बिट प्रिसिजन के बजाय।

FLUX.1-dev के लिए, ट्रांसफॉर्मर घटक (मॉडल का सबसे बड़ा हिस्सा) को क्वांटाइज किया जा सकता है, जो इसकी मेमोरी फुटप्रिंट को Q8_0 क्वांटाइजेशन के साथ लगभग 24GB से 12GB तक कम करता है, या और अधिक क्वांटाइजेशन स्तरों के साथ और कम।

GGUF क्वांटाइजेशन के फायदे

GGUF क्वांटाइज्ड FLUX मॉडल का उपयोग करने के प्राथमिक लाभ शामिल हैं:

  • कम मेमोरी उपयोग: VRAM आवश्यकताओं को आधा कर देता है, जिससे FLUX.1-dev अधिक हार्डवेयर पर सुलभ हो जाता है
  • क्वालिटी बनाए रखना: Q8_0 क्वांटाइजेशन इमेज क्वालिटी को बनाए रखता है जिसमें न्यूनतम दृश्य अंतर
  • तेज लोडिंग: क्वांटाइज्ड मॉडल छोटे फाइल साइज के कारण तेजी से लोड होते हैं
  • कम बिजली खपत: कम मेमोरी उपयोग इन्फरेंस के दौरान कम बिजली खपत का मतलब है

हमारे टेस्टिंग में, क्वांटाइज्ड मॉडल लगभग 12-15GB VRAM का उपयोग करता है जबकि पूर्ण मॉडल के लिए 24GB+ है, जबकि जनरेशन समय लगभग समान रहता है।

इंस्टॉलेशन और सेटअप

GGUF क्वांटाइज्ड FLUX.1-dev का उपयोग करने के लिए, आपको gguf पैकेज की आवश्यकता होगी इसके अलावा स्टैंडर्ड डिफ्यूज़र्स डिपेंडेंसीज। अगर आप पहले से ही FLUX का उपयोग टेक्स्ट-टू-इमेज जनरेशन के लिए कर रहे हैं, तो आपको बेस सेटअप से परिचित होना चाहिए।

अगर आप uv को अपना Python पैकेज मैनेजर के रूप में उपयोग कर रहे हैं, तो आप आवश्यक पैकेजों को इस प्रकार इंस्टॉल कर सकते हैं:

uv pip install -U diffusers torch transformers gguf

या स्टैंडर्ड pip के साथ:

pip install -U diffusers torch transformers gguf

इम्प्लीमेंटेशन

GGUF क्वांटाइज्ड मॉडल का उपयोग करने का मुख्य अंतर यह है कि आप FluxTransformer2DModel.from_single_file() का उपयोग करके ट्रांसफॉर्मर को अलग से लोड करते हैं जिसमें GGUFQuantizationConfig होता है, फिर इसे पाइपलाइन में पास करते हैं। अगर आपको Python सिंटैक्स के लिए एक तेज़ संदर्भ की आवश्यकता है, तो Python Cheatsheet देखें। यहां एक पूर्ण कार्यात्मक उदाहरण है:

import os
import torch
from diffusers import FluxPipeline, FluxTransformer2DModel, GGUFQuantizationConfig

# पथ
gguf_model_path = "/path/to/flux1-dev-Q8_0.gguf"
base_model_path = "/path/to/FLUX.1-dev-config"  # केवल कॉन्फ़िग फ़ाइलें

# GGUF क्वांटाइज्ड ट्रांसफॉर्मर लोड करें
print(f"GGUF क्वांटाइज्ड ट्रांसफॉर्मर लोड कर रहा हूँ: {gguf_model_path}")
transformer = FluxTransformer2DModel.from_single_file(
    gguf_model_path,
    quantization_config=GGUFQuantizationConfig(compute_dtype=torch.bfloat16),
    config=base_model_path,
    subfolder="transformer",
    torch_dtype=torch.bfloat16,
)

# क्वांटाइज्ड ट्रांसफॉर्मर के साथ पाइपलाइन बनाएं
print(f"बेस मॉडल के साथ पाइपलाइन बन रहा हूँ: {base_model_path}")
pipe = FluxPipeline.from_pretrained(
    base_model_path,
    transformer=transformer,
    torch_dtype=torch.bfloat16,
)

# CPU ऑफलोडिंग सक्षम करें (GGUF के लिए आवश्यक)
pipe.enable_model_cpu_offload()
# नोट: enable_sequential_cpu_offload() GGUF के साथ संगत नहीं है

# इमेज जनरेट करें
prompt = "सूर्यास्त के समय नीले प्रकाश उत्सर्जित करने वाले निओन लाइट्स के साथ एक भविष्यवाणी शहर का दृश्य"
image = pipe(
    prompt,
    height=496,
    width=680,
    guidance_scale=3.5,
    num_inference_steps=60,
    max_sequence_length=512,
    generator=torch.Generator("cpu").manual_seed(42)
).images[0]

image.save("output.jpg")

महत्वपूर्ण विचार

मॉडल कॉन्फ़िगरेशन फ़ाइलें

GGUF क्वांटाइजेशन का उपयोग करते समय, आपको मूल FLUX.1-dev मॉडल से मॉडल कॉन्फ़िगरेशन फ़ाइलें अभी भी चाहिए। इसमें शामिल हैं:

  • model_index.json - पाइपलाइन संरचना
  • घटक कॉन्फ़िग (ट्रांसफॉर्मर, टेक्स्ट_एनकोडर, टेक्स्ट_एनकोडर_2, VAE, स्केड्यूलर)
  • टोकनाइज़र फ़ाइलें
  • टेक्स्ट एनकोडर और VAE वेट्स (इनको क्वांटाइज नहीं किया जाता)

ट्रांसफॉर्मर वेट्स GGUF फ़ाइल से आते हैं, लेकिन सभी अन्य घटकों को मूल मॉडल फ़ाइलें चाहिए।

CPU ऑफलोडिंग संगतता

महत्वपूर्ण: enable_sequential_cpu_offload() GGUF क्वांटाइज्ड मॉडल के साथ संगत नहीं है और KeyError: None त्रुटि उत्पन्न करेगा। मैं क्वांटाइज्ड ट्रांसफॉर्मर के साथ काम करते समय enable_model_cpu_offload() का उपयोग कर रहा हूँ।

क्वांटाइजेशन स्तर

FLUX.1-dev के लिए उपलब्ध क्वांटाइजेशन स्तर शामिल हैं:

  • Q8_0: सर्वोत्तम क्वालिटी, ~14-15GB मेमोरी (सिफारिश की जाती है)
  • Q6_K: अच्छा संतुलन, ~12GB मेमोरी
  • Q4_K: अधिकतम संपीड़न, ~8GB मेमोरी (मैं मानता हूँ कि यह क्वालिटी को अच्छी तरह से प्रभावित करता है)

अधिकांश उपयोग के मामलों के लिए, Q8_0 मेमोरी बचत और इमेज क्वालिटी के बीच सर्वोत्तम संतुलन प्रदान करता है।

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

हमारे टेस्टिंग में समान प्रॉम्प्ट और सेटिंग्स के साथ:

मॉडल VRAM उपयोग जनरेशन समय क्वालिटी
पूर्ण FLUX.1-dev 24GB? मेरे पास इतना बड़ा GPU नहीं है उत्कृष्ट (मैं सोचता हूँ)
पूर्ण FLUX.1-dev ~3GB के साथ sequential_cpu_offload() ~329s उत्कृष्ट
GGUF Q8_0 ~14-15GB ~98s !!! उत्कृष्ट
GGUF Q6_K ~10-12GB ~116s बहुत अच्छा

क्वांटाइज्ड मॉडल, क्योंकि अब इसे कम CPU ऑफलोड की आवश्यकता है, मेमोरी का उपयोग करने के साथ-साथ जनरेशन स्पीड में तीन गुना तेज़ है, जिससे इसे सीमित VRAM वाले सिस्टम के लिए व्यावहारिक बनाता है।

मैंने दोनों मॉडल के साथ इस प्रॉम्प्ट का टेस्ट किया:

एक भविष्यवाणी क्लोज-अप ट्रांसफॉर्मर इन्फरेंस ASIC चिप के साथ जटिल सर्किटरी, घनी मैट्रिक्स मल्टीप्लाई यूनिट्स और कम-प्रिसिजन ALUs से नीले प्रकाश उत्सर्जित करते हुए, ऑन-चिप SRAM बफर्स और क्वांटाइजेशन पाइपलाइन्स से घिरा हुआ, हाइपर-डिटेल्ड फोटोरियलिस्टिक स्टाइल में रेंडर किया गया है, एक ठंडा, क्लिनिकल लाइटिंग स्कीम के साथ।

FLUX.1-dev Q8 का सैंपल आउटपुट इस पोस्ट का कवर इमेज है - ऊपर देखें।

नॉन-क्वांटाइज्ड FLUX.1-dev का सैंपल आउटपुट नीचे है:

नॉन-क्वांटाइज्ड FLUX.1-dev द्वारा उत्पन्न उदाहरण इमेज - asic

मुझे क्वालिटी में बहुत अंतर नहीं दिखता।

निष्कर्ष

GGUF क्वांटाइजेशन FLUX.1-dev को अधिक व्यापक हार्डवेयर रेंज तक सुलभ बनाता है जबकि मॉडल के लिए प्रसिद्ध उच्च-गुणवत्ता वाले इमेज जनरेशन को बनाए रखता है। मेमोरी आवश्यकताओं को लगभग 50% कम करके, आप अधिक किफायती हार्डवेयर पर स्टेट-ऑफ-द-आर्ट टेक्स्ट-टू-इमेज जनरेशन कर सकते हैं बिना महत्वपूर्ण क्वालिटी हानि के।

इम्प्लीमेंटेशन डिफ्यूज़र्स लाइब्रेरी के साथ सीधा है, जो स्टैंडर्ड FLUX पाइपलाइन सेटअप में केवल छोटे बदलावों की आवश्यकता है। अधिकांश उपयोगकर्ताओं के लिए, Q8_0 क्वांटाइजेशन मेमोरी दक्षता और इमेज क्वालिटी के बीच सर्वोत्तम संतुलन प्रदान करता है।

अगर आप FLUX.1-Kontext-dev का उपयोग इमेज ऑगमेंटेशन के लिए कर रहे हैं, तो भविष्य में समान क्वांटाइजेशन तकनीकों की उपलब्धि हो सकती है।

संबंधित लेख

संदर्भ