Uruchamianie FLUX.1-dev GGUF Q8 w Pythonie

Przyspiesz FLUX.1-dev za pomocą kwantyzacji GGUF

Page content

FLUX.1-dev to potężny model generowania obrazów na podstawie tekstu, który daje wspaniałe wyniki, ale jego wymagania co do pamięci (24 GB i więcej) sprawiają, że trudno go uruchomić na wielu systemach. GGUF quantization of FLUX.1-dev oferta rozwiązania, które zmniejsza zużycie pamięci o około 50%, jednocześnie zachowując bardzo dobre jakość obrazów.

przykładowy wynik Q8 quantized FLUX.1-dev - asic Ten obraz został wygenerowany za pomocą modelu Q8 quantized FLUX.1-dev w formacie GGUF, pokazując, że jakość jest zachowana nawet przy zmniejszonym zużyciu pamięci.

Co to jest GGUF Quantization?

GGUF (GPT-Generated Unified Format) to format kwantyzacji opracowany pierwotnie dla modeli językowych, ale obecnie wspierany również dla modeli dyfuzji, takich jak FLUX. Kwantyzacja zmniejsza rozmiar modelu, przechowując wagi w formatach o niższej precyzji (8-bit, 6-bit lub 4-bit) zamiast pełnej precyzji 16-bit lub 32-bit.

Dla FLUX.1-dev, komponent transformer (największa część modelu) może zostać skwantyzowany, zmniejszając jego zużycie pamięci z około 24 GB do 12 GB przy kwantyzacji Q8_0, a nawet mniejszym przy bardziej agresywnych poziomach kwantyzacji.

Zalety GGUF Quantization

Główne zalety użycia modeli FLUX skwantyzowanych w formacie GGUF obejmują:

  • Zmniejszone zużycie pamięci: Obniżenie wymagań VRAM o połowę, co sprawia, że FLUX.1-dev jest dostępny na większej liczbie sprzętu
  • Zachowana jakość: Kwantyzacja Q8_0 zachowuje jakość obrazu z minimalnymi różnicami widzialnymi
  • Szybsze ładowanie: Modele skwantyzowane ładują się szybciej dzięki mniejszym rozmiarom plików
  • Niskie zużycie energii: Zmniejszone zużycie pamięci przekłada się na niższe zużycie energii podczas inferencji

W naszych testach model skwantyzowany zużywa około 12–15 GB VRAM w porównaniu do 24 GB i więcej dla pełnego modelu, a czas generowania pozostaje podobny.

Instalacja i konfiguracja

Aby użyć modelu FLUX.1-dev skwantyzowanego w formacie GGUF, potrzebujesz pakietu gguf oprócz standardowych zależności diffusers. Jeśli już korzystasz z FLUX do generowania obrazów na podstawie tekstu, jesteś znany z podstawowej konfiguracji.

Jeśli korzystasz z uv jako zarządcy pakietów Pythona, możesz zainstalować wymagane pakiety za pomocą:

uv pip install -U diffusers torch transformers gguf

Lub za pomocą standardowego pip:

pip install -U diffusers torch transformers gguf

Implementacja

Główne różnice przy użyciu modeli skwantyzowanych w formacie GGUF polegają na tym, że ładujesz transformer osobno za pomocą FluxTransformer2DModel.from_single_file() z GGUFQuantizationConfig, a następnie przekazujesz go do pipeline. Jeśli potrzebujesz szybkiego odniesienia do składni Pythona, sprawdź Python Cheatsheet. Oto kompletny działający przykład:

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

# Ścieżki
gguf_model_path = "/ścieżka/do/flux1-dev-Q8_0.gguf"
base_model_path = "/ścieżka/do/FLUX.1-dev-config"  # Tylko pliki konfiguracyjne

# Załaduj skwantyzowany transformer GGUF
print(f"Ładowanie skwantyzowanego transformera GGUF z: {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,
)

# Utwórz pipeline z użyciem skwantyzowanego transformera
print(f"Tworzenie pipeline z modelem bazowym: {base_model_path}")
pipe = FluxPipeline.from_pretrained(
    base_model_path,
    transformer=transformer,
    torch_dtype=torch.bfloat16,
)

# Włącz przekazywanie do CPU (wymagane dla GGUF)
pipe.enable_model_cpu_offload()
# Uwaga: enable_sequential_cpu_offload() nie jest kompatybilne z GGUF

# Wygeneruj obraz
prompt = "Futurystyczny krajobraz miasta w zachodzie słońca z neonowymi światłami"
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")

Ważne uwagi

Pliki konfiguracyjne modelu

Podczas użycia kwantyzacji GGUF nadal potrzebujesz plików konfiguracyjnych oryginalnego modelu FLUX.1-dev. Obejmują one:

  • model_index.json - Struktura pipeline
  • Konfiguracje komponentów (transformer, text_encoder, text_encoder_2, vae, scheduler)
  • Pliki tokenizera
  • Wagi text encoder i VAE (nie są skwantyzowane)

Wagi transformera pochodzą z pliku GGUF, ale wszystkie inne komponenty wymagają oryginalnych plików modelu.

Kompatybilność z przekazywaniem do CPU

Ważne: enable_sequential_cpu_offload() nie jest kompatybilne z modelami skwantyzowanymi w formacie GGUF i spowoduje błąd KeyError: None. Używam zamiast tego enable_model_cpu_offload() podczas pracy z transformercami skwantyzowanymi.

Poziomy kwantyzacji

Dostępne poziomy kwantyzacji dla FLUX.1-dev obejmują:

  • Q8_0: Najlepsza jakość, ~14–15 GB pamięci (zalecane)
  • Q6_K: Dobrze zrównoważony, ~12 GB pamięci
  • Q4_K: Maksymalne skompresowanie, ~8 GB pamięci (przypuszczam, że wpływa to negatywnie na jakość)

Dla większości przypadków użycia Q8_0 zapewnia najlepszy zrównoważony poziom oszczędzania pamięci i jakości obrazu.

Porównanie wydajności

W naszych testach przy identycznych promptach i ustawieniach:

Model Użycie VRAM Czas generowania Jakość
Pełny FLUX.1-dev 24 GB? Nie mam GPU takiego rozmiaru Wspaniała (przypuszczam)
Pełny FLUX.1-dev ~3 GB z sequential_cpu_offload() ~329 s Wspaniała
GGUF Q8_0 ~14–15 GB ~98 s !!! Wspaniała
GGUF Q6_K ~10–12 GB ~116 s Bardzo dobra

Model skwantyzowany, ponieważ wymaga teraz mniejszego przekazywania do CPU, ma ponad 3 razy szybszy czas generowania, jednocześnie zużywając znacznie mniej pamięci, co czyni go praktycznym dla systemów z ograniczoną pamięcią VRAM.

Przetestowałem oba modele z promptem:

Futurystyczne zbliżenie na chip inferencji transformera ASIC z złożonymi obwodami, emitującym niebieskie światło z gęstych jednostek mnożenia macierzy i niskiej precyzji ALU, otoczonych buforami SRAM na chipie i pipeline'ami kwantyzacji, wyrenderowany w bardzo szczegółowym stylu fotorealistycznym z chłodnym, klinicznym schematem oświetlenia.

Przykładowy wynik FLUX.1-dev Q8 to obraz okładki tego posta – zobacz powyżej.

Przykładowy wynik nieskwantyzowanego FLUX.1-dev znajduje się poniżej:

przykładowy obraz wygenerowany przez nieskwantyzowany FLUX.1-dev - asic

Nie widzę dużej różnicy w jakości.

Podsumowanie

Kwantyzacja GGUF czyni FLUX.1-dev dostępna dla szerszego zakresu sprzętu, jednocześnie zachowując wysoką jakość generowania obrazów, dla której model jest znany. Poprzez zmniejszenie wymagań pamięci o około 50%, możesz uruchomić najnowsze generowanie obrazów na podstawie tekstu na bardziej dostępnych sprzęcie bez znacznego utraty jakości.

Implementacja jest prosta dzięki bibliotece diffusers, wymagając jedynie drobnych zmian w standardowej konfiguracji pipeline FLUX. Dla większości użytkowników, kwantyzacja Q8_0 zapewnia optymalny zrównoważony poziom efektywności pamięci i jakości obrazu.

Jeśli pracujesz z FLUX.1-Kontext-dev do wzmocnienia obrazów, podobne techniki kwantyzacji mogą stać się dostępne w przyszłości.

Powiązane artykuły

Źródła