Bagaimana saya menjalankan model fluks pada 8GB GPU RAM? - Analytics Vidhya

Model Flux Labs Black Forest yang baru -baru ini telah mendapat populariti untuk keupayaan penjanaan imejnya yang mengagumkan. Walau bagaimanapun, saiznya pada mulanya menghalang penggunaannya pada perkakasan pengguna standard. Batasan ini mendorong penggunaan perkhidmatan API untuk mengelakkan pemuatan model tempatan. Walau bagaimanapun, penggunaan premis kekal mahal kerana keperluan GPU. Mujurlah, memeluk Perpustakaan Diffusers Face kini menyokong kuantisasi melalui Bitsandbytes, yang membolehkan kesimpulan fluks pada mesin dengan hanya 8GB GPU RAM.

Objektif Pembelajaran:

• Konfigurasikan kebergantungan untuk menggunakan fluks dalam persekitaran colab.
• Encode teks meminta menggunakan pengekod teks kuantitatif 4-bit untuk kecekapan memori.
• Melaksanakan teknik penjimatan memori untuk memuatkan dan menjalankan model penjanaan imej dalam ketepatan campuran.
• Menjana imej dari teks yang diminta menggunakan saluran paip fluks dalam colab.

Artikel ini adalah sebahagian daripada Blogathon Sains Data.

Jadual Kandungan:

• Objektif pembelajaran
• Apa itu fluks?
• Mengapa kuantisasi penting?
  • Kuantisasi dengan bitsandbytes
  • Bagaimana Bitsandbytes berfungsi?
• Menjalankan fluks pada perkakasan pengguna
  • Langkah 1: Persediaan Persekitaran
  • Langkah 2: Pengurusan Memori GPU
  • Langkah 3: Memuatkan pengekod teks T5 4-bit
  • Langkah 4: Menjana embeddings teks
  • Langkah 5: Memuatkan Transformer 4-Bit dan VAE
  • Langkah 6: Generasi Imej
• Masa Depan Generasi Imej Di Perundingan
• Kesimpulan
  • Takeaways utama
• Soalan yang sering ditanya

Apa itu fluks?

Fluks, yang dibangunkan oleh Black Forest Labs (pencipta penyebaran stabil), mewakili kemajuan yang signifikan dalam model teks-ke-imej. Ia membina penyebaran yang stabil, menawarkan prestasi dan kualiti output yang lebih baik. Walaupun pada mulanya sumber intensif, pengoptimuman membolehkan pelaksanaan yang cekap pada perkakasan pengguna. Artikel ini menunjukkan bagaimana kuantisasi meningkatkan kebolehcapaian Flux. Imej di bawah menggambarkan perdagangan antara potensi kreatif dan kos pengiraan.

Flux mempunyai beberapa komponen seni bina utama:

• Dua pengekod teks pra-terlatih (klip dan T5): Pengekod ini meningkatkan pemahaman dan terjemahan segera teks ke dalam imej.
• Model DIT berasaskan Transformer: Backbone yang mengutuk ini memanfaatkan transformer untuk kecekapan dan ketepatan.
• Variasi Auto-Scoder (VAE): Pemprosesan dalam ruang laten mengurangkan permintaan pengiraan sambil mengekalkan kualiti imej.

Flux boleh didapati dalam beberapa versi: Flux-Schnell (sumber terbuka), Flux-dev (dibuka, dengan lesen yang lebih ketat), dan Flux-Pro (tertutup-sumber, API-diakses).

Mengapa kuantisasi penting?

Kuantisasi, teknik untuk mengurangkan saiz model dengan menyimpan parameter menggunakan bit yang lebih sedikit, adalah penting untuk menjalankan model besar pada perkakasan terhad. Walaupun kurang biasa dalam penjanaan imej, ia dengan ketara mengurangkan jejak memori tanpa kehilangan prestasi yang besar. Parameter rangkaian saraf biasanya disimpan dalam 32 bit, tetapi kuantisasi dapat mengurangkan ini hingga 4 bit.

Kuantisasi dengan bitsandbytes

Perpustakaan Bitsandbytes membolehkan kuantisasi K-bit yang cekap untuk pytorch. Integrasi ke dalam perpustakaan diffusers membuat fluks berjalan pada 8GB GPU boleh dilaksanakan.

Bagaimana Bitsandbytes berfungsi?

Bitsandbytes mengukur kepada ketepatan 8 dan 4-bit. Kuantisasi 8-bit mengendalikan outliers secara berbeza untuk meminimumkan kemerosotan prestasi. Kuantisasi 4-bit selanjutnya memampatkan model, sering digunakan dengan Qlora untuk penalaan halus.

Menjalankan fluks pada perkakasan pengguna

Langkah 1: Persediaan Persekitaran

Pastikan persekitaran yang dibolehkan GPU (misalnya, NVIDIA T4/L4 atau Google Colab). Pasang pakej yang diperlukan:

 ! Pip Install -uq git https://github.com/huggingface/diffusers@main
! Pip Install -uq git https://github.com/huggingface/transformers@main
! Pip Install -UQ Bitsandbytes

Ketergantungan Import:

 Import diffusers
Import Transformers
Import Bitsandbytes sebagai BNB
dari diffuser import fluxpipeline, fluxtransformer2dmodel
Dari Transformers Import T5encodermodel
obor import
Import GC

Langkah 2: Pengurusan Memori GPU

Tentukan fungsi untuk membersihkan memori GPU antara beban model:

 Def Flush ():
    gc.collect ()
    obor.cuda.empty_cache ()
    obor.cuda.reset_max_memory_allocated ()
    obor.cuda.reset_peak_memory_stats ()

Flush ()

Langkah 3: Memuatkan pengekod teks T5 4-bit

Muatkan pengekod T5 menggunakan kuantisasi 4-bit:

 ckpt_id = "Black-Forest-Labs/Flux.1-Dev"
ckpt_4bit_id = "hf-internal-testing/fluks.1-dev-nf4-pkg"
prompt = "Anjing comel di Paris Photoshoot"

text_encoder_2_4bit = t5encodermodel.from_pretrained (
    ckpt_4bit_id,
    subfolder = "text_encoder_2",
)

Langkah 4: Menjana embeddings teks

Kodkan prompt menggunakan encoder kuantitatif:

 saluran paip = fluxpipeline.from_pretrained (
    "Black-forest-labs/fluks.1-dev",
    text_encoder_2 = text_encoder_2_4bit,
    Transformer = Tiada,
    vae = tiada,
    obor_dtype = obor.float16,
)

dengan obor.no_grad ():
    prompt_embeds, pooled_prompt_embeds, text_ids = pipeline.encode_prompt (
        prompt = prompt, prompt_2 = tiada, max_sequence_length = 256
    )

Del Pipeline
Flush ()

Langkah 5: Memuatkan Transformer 4-Bit dan VAE

Muatkan Transformer dan VAE dalam mod 4-bit:

 transformer_4bit = fluxtransformer2dmodel.from_pretrained (ckpt_4bit_id, subfolder = "transformer")
saluran paip = fluxpipeline.from_pretrained (
    ckpt_id,
    text_encoder = Tiada,
    text_encoder_2 = Tiada,
    tokenizer = tiada,
    tokenizer_2 = Tiada,
    Transformer = Transformer_4bit,
    obor_dtype = obor.float16,
)

pipeline.enable_model_cpu_offload ()

Langkah 6: Generasi Imej

Menjana gambar:

 Cetak ("Denoising Running.")
ketinggian, lebar = 512, 768
gambar = saluran paip (
    prompt_embeds = prompt_embeds,
    pooled_prompt_embeds = pooled_prompt_embeds,
    num_inference_steps = 50,
    panduan_scale = 5.5,
    ketinggian = ketinggian,
    lebar = lebar,
    output_type = "pil",
) .Images

Imej [0] 

Masa Depan Generasi Imej Di Perundingan

Pengendalian model kuantisasi dan cekap membawa AI yang kuat kepada perkakasan pengguna, mendemokrasikan akses kepada penjanaan imej maju.

Kesimpulan

Fluks, digabungkan dengan kuantisasi, membolehkan penjanaan imej berkualiti tinggi pada GPU 8GB. Kemajuan ini menjadikan AI yang canggih dapat diakses oleh penonton yang lebih luas.

Takeaways Kunci:

• Fluks berjalan dengan cekap dalam colab menggunakan kuantisasi 4-bit dan ketepatan bercampur.
• diffusers dan transformers memudahkan penjanaan imej.
• Pengurusan memori yang berkesan membolehkan pelaksanaan model yang besar terhadap sumber terhad.

Soalan yang sering ditanya (sama seperti asal, tetapi diperbaharui untuk kebolehbacaan yang lebih baik)

Q1. Tujuan kuantisasi 4-bit? Kuantisasi 4-bit mengurangkan penggunaan memori, yang membolehkan model besar seperti fluks berjalan dengan cekap pada sumber yang terhad.

S2. Menukar Prompt Teks? Ganti pemboleh ubah prompt dengan keterangan teks yang anda inginkan.

Q3. Menyesuaikan kualiti/gaya imej? Laraskan num_inference_steps (kualiti) dan guidance_scale (pematuhan segera) dalam panggilan saluran paip.

Q4. Mengendalikan kesilapan memori di colab? Memastikan penggunaan GPU, kuantisasi 4-bit, dan ketepatan bercampur. Pertimbangkan untuk menurunkan num_inference_steps atau menggunakan cpu offloading.

S5. Menjalankan skrip secara tempatan? Ya, tetapi pastikan sumber dan ingatan GPU yang mencukupi.

Atas ialah kandungan terperinci Bagaimana saya menjalankan model fluks pada 8GB GPU RAM? - Analytics Vidhya. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!