Menjalankan FLUX.1-dev GGUF Q8 dalam Python

Percepat FLUX.1-dev dengan kuantisasi GGUF

Konten Halaman

FLUX.1-dev adalah model teks-ke-gambar yang kuat yang menghasilkan hasil yang luar biasa, tetapi kebutuhan memori 24GB+ membuatnya menantang untuk dijalankan pada banyak sistem. GGUF quantization dari FLUX.1-dev menyediakan solusi, mengurangi penggunaan memori sekitar 50% sambil mempertahankan kualitas gambar yang sangat baik.

contoh output Q8 quantized FLUX.1-dev - asic Gambar ini dihasilkan menggunakan model FLUX.1-dev yang telah dikuantisasi Q8 dalam format GGUF, menunjukkan bahwa kualitas tetap terjaga meskipun dengan pengurangan ukuran memori.

Apa itu GGUF Quantization?

GGUF (GPT-Generated Unified Format) adalah format kuantisasi yang awalnya dikembangkan untuk model bahasa tetapi sekarang didukung untuk model difusi seperti FLUX. Kuantisasi mengurangi ukuran model dengan menyimpan bobot dalam format presisi yang lebih rendah (8-bit, 6-bit, atau 4-bit) daripada presisi penuh 16-bit atau 32-bit.

Untuk FLUX.1-dev, komponen transformer (bagian terbesar dari model) dapat dikuantisasi, mengurangi ukuran memori dari sekitar 24GB menjadi 12GB dengan kuantisasi Q8_0, atau bahkan lebih rendah dengan tingkat kuantisasi yang lebih agresif.

Manfaat GGUF Quantization

Keuntungan utama dari menggunakan model FLUX yang dikuantisasi GGUF meliputi:

  • Penggunaan Memori yang Lebih Rendah: Potong kebutuhan VRAM hingga setengah, membuat FLUX.1-dev dapat diakses pada lebih banyak perangkat keras
  • Kualitas yang Dipertahankan: Kuantisasi Q8_0 mempertahankan kualitas gambar dengan perbedaan yang sangat minimal
  • Pemuatan yang Lebih Cepat: Model yang dikuantisasi memuat lebih cepat karena ukuran file yang lebih kecil
  • Konsumsi Daya yang Lebih Rendah: Penggunaan memori yang lebih rendah berarti konsumsi daya yang lebih rendah selama inferensi

Dalam pengujian kami, model yang dikuantisasi menggunakan sekitar 12-15GB VRAM dibandingkan 24GB+ untuk model penuh, sementara waktu generasi tetap sama.

Instalasi dan Pengaturan

Untuk menggunakan FLUX.1-dev yang dikuantisasi GGUF, Anda akan membutuhkan paket gguf selain ketergantungan diffusers standar. Jika Anda sudah menggunakan FLUX untuk generasi gambar dari teks, Anda sudah familiar dengan pengaturan dasar.

Jika Anda menggunakan uv sebagai manajer paket Python Anda, Anda dapat menginstal paket yang diperlukan dengan:

uv pip install -U diffusers torch transformers gguf

Atau dengan pip standar:

pip install -U diffusers torch transformers gguf

Implementasi

Perbedaan utama saat menggunakan model GGUF yang dikuantisasi adalah bahwa Anda memuat transformer secara terpisah menggunakan FluxTransformer2DModel.from_single_file() dengan GGUFQuantizationConfig, lalu mengirimkannya ke pipeline. Jika Anda membutuhkan referensi cepat untuk sintaks Python, lihat Python Cheatsheet. Berikut adalah contoh lengkap yang dapat berjalan:

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

# Jalur
gguf_model_path = "/path/to/flux1-dev-Q8_0.gguf"
base_model_path = "/path/to/FLUX.1-dev-config"  # Hanya file konfigurasi

# Muat transformer yang dikuantisasi GGUF
print(f"Memuat transformer yang dikuantisasi GGUF dari: {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,
)

# Buat pipeline dengan transformer yang dikuantisasi
print(f"Membuat pipeline dengan model dasar: {base_model_path}")
pipe = FluxPipeline.from_pretrained(
    base_model_path,
    transformer=transformer,
    torch_dtype=torch.bfloat16,
)

# Aktifkan offloading CPU (diperlukan untuk GGUF)
pipe.enable_model_cpu_offload()
# Catatan: enable_sequential_cpu_offload() tidak kompatibel dengan GGUF

# Buat gambar
prompt = "Pemandangan kota masa depan di tengah matahari terbenam dengan lampu neon"
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")

Pertimbangan Penting

File Konfigurasi Model

Ketika menggunakan kuantisasi GGUF, Anda masih membutuhkan file konfigurasi model dari model FLUX.1-dev asli. Ini termasuk:

  • model_index.json - Struktur pipeline
  • Konfigurasi komponen (transformer, text_encoder, text_encoder_2, vae, scheduler)
  • File tokenizer
  • Bobot text encoder dan VAE (ini tidak dikuantisasi)

Bobot transformer berasal dari file GGUF, tetapi semua komponen lainnya memerlukan file model asli.

Kompatibilitas Offloading CPU

Penting: enable_sequential_cpu_offload() tidak kompatibel dengan model GGUF yang dikuantisasi dan akan menyebabkan kesalahan KeyError: None. Saya hanya menggunakan enable_model_cpu_offload() saat bekerja dengan transformer yang dikuantisasi.

Tingkat Kuantisasi

Tingkat kuantisasi yang tersedia untuk FLUX.1-dev meliputi:

  • Q8_0: Kualitas terbaik, ~14-15GB memori (direkomendasikan)
  • Q6_K: Keseimbangan yang baik, ~12GB memori
  • Q4_K: Kompresi maksimal, ~8GB memori (saya mengasumsikan ini memengaruhi kualitas secara negatif)

Untuk sebagian besar kasus penggunaan, Q8_0 memberikan keseimbangan terbaik antara penghematan memori dan kualitas gambar.

Perbandingan Kinerja

Dalam pengujian kami dengan prompt dan pengaturan yang identik:

Model Penggunaan VRAM Waktu Generasi Kualitas
FLUX.1-dev Penuh 24GB? Saya tidak memiliki GPU sebesar itu Excellent (Saya pikir)
FLUX.1-dev Penuh ~3GB dengan sequential_cpu_offload() ~329s Excellent
GGUF Q8_0 ~14-15GB ~98s !!! Excellent
GGUF Q6_K ~10-12GB ~116s Sangat Baik

Model yang dikuantisasi, karena sekarang memerlukan offloading CPU yang lebih sedikit, memiliki kecepatan generasi yang lebih dari tiga kali lebih cepat sambil menggunakan memori yang jauh lebih sedikit, membuatnya praktis untuk sistem dengan VRAM terbatas.

Saya menguji kedua model dengan prompt:

Perhatian dekat dari chip ASIC inferensi transformer masa depan dengan sirkuit yang rumit, cahaya biru bercahaya dari unit perkalian matriks padat dan ALU presisi rendah, dikelilingi oleh buffer SRAM on-chip dan pipeline kuantisasi, dirender dalam gaya fotorealistik yang sangat detail dengan skema pencahayaan dingin dan klinis.

Contoh output dari FLUX.1-dev Q8 adalah gambar sampul untuk posting ini - lihat di atas.

Contoh output dari FLUX.1-dev yang tidak dikuantisasi berada di bawah ini:

contoh gambar yang dihasilkan oleh FLUX.1-dev yang tidak dikuantisasi - asic

Saya tidak melihat perbedaan besar dalam kualitas.

Kesimpulan

Kuantisasi GGUF membuat FLUX.1-dev dapat diakses oleh berbagai perangkat keras dengan mempertahankan kualitas generasi gambar tinggi yang dikenal oleh model tersebut. Dengan mengurangi kebutuhan memori sekitar 50%, Anda dapat menjalankan generasi gambar teks-ke-gambar terkini pada perangkat keras yang lebih terjangkau tanpa kehilangan kualitas yang signifikan.

Implementasinya sederhana dengan library diffusers, hanya memerlukan sedikit perubahan pada pengaturan pipeline FLUX standar. Untuk sebagian besar pengguna, kuantisasi Q8_0 memberikan keseimbangan optimal antara efisiensi memori dan kualitas gambar.

Jika Anda bekerja dengan FLUX.1-Kontext-dev untuk augmentasi gambar, teknik kuantisasi serupa mungkin tersedia di masa depan.

Artikel Terkait

Referensi