Cara Menjalankan FLUX.2 Secara Lokal di RTX 3090

Dalam tutorial ini, kita akan mempelajari cara menjalankan model pembuatan gambar FLUX.2 secara lokal. Kita akan menyiapkan lingkungan GPU, mengunduh versi FLUX.2 yang telah dikuantisasi, memuatnya secara efisien ke memori GPU dan RAM, menjalankan inferensi, lalu bereksperimen dengan berbagai opsi konfigurasi.

Menjalankan model sebesar ini pada RTX 3090 bisa menantang, dan tutorial ini berfokus pada cara paling sederhana dan praktis untuk membuat FLUX.2 berjalan secara lokal tanpa kerumitan yang tidak perlu.

Jika Anda tertarik dengan teknik lanjutan dalam pengelolaan dan optimalisasi model, termasuk pruning, kuantisasi, dan logging, saya merekomendasikan mengikuti kursus Scalable AI Models with PyTorch Lightning. 

Apa itu FLUX.2?

FLUX.2 adalah model pembuatan gambar yang dibuat untuk pekerjaan kreatif nyata, bukan sekadar eksperimen. Model ini menghasilkan gambar berkualitas tinggi dan realistis sambil menjaga konsistensi karakter, gaya, dan produk di berbagai gambar referensi. Membangun dari model FLUX asli, model ini mengikuti prompt dengan akurat, merender teks dengan jelas, serta menangani pencahayaan, tata letak, dan branding dengan baik. 

FLUX.2 juga mendukung pengeditan gambar dengan resolusi tinggi dan tersedia baik sebagai API siap pakai maupun model terbuka yang dapat Anda jalankan secara lokal, sehingga praktis, fleksibel, dan mudah diintegrasikan ke alur kerja produksi nyata.

FLUX.2 hadir dalam empat varian utama: 

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

Masing-masing dirancang untuk tingkat kontrol, performa, dan kebutuhan penerapan yang berbeda. 

Dalam perbandingan leaderboard yang lebih luas, ketiga varian FLUX.2 menempati peringkat 10 besar model pengeditan gambar pada leaderboard Artificial Analysis, dengan FLUX.2 [max] dan FLUX.2 [pro] mengungguli model seperti GPT-5 dan generasi sebelumnya, varian FLUX.1 Kontext.

Sumber: Text to Image Leaderboard | Artificial Analysis

Menjalankan FLUX.2 Secara Lokal: Panduan Langkah demi Langkah

Pada langkah-langkah berikut, saya akan menjelaskan semua yang perlu Anda ketahui untuk menjalankan FLUX.2 secara lokal menggunakan GPU RTX 3090. 

1. Persyaratan sistem dan prasyarat

Sebelum menjalankan FLUX.2 secara lokal, pastikan sistem Anda telah dikonfigurasi dengan benar untuk inferensi GPU.

Perangkat keras

• GPU NVIDIA (disarankan RTX 3090)
• 24 GB VRAM
• 64 GB RAM sistem direkomendasikan

Driver NVIDIA dan CUDA Toolkit

• Instal Driver NVIDIA: Pastikan Anda menginstal driver GPU NVIDIA terbaru dengan dukungan untuk versi CUDA terkini (disarankan CUDA 12.1+).
• Instal CUDA Toolkit: Unduh dan instal CUDA Toolkit dari halaman resmi NVIDIA CUDA Downloads untuk meningkatkan kompatibilitas dengan ekstensi GPU dan kernel kustom.

Jalankan perintah berikut di terminal untuk memverifikasi instalasi:

nvidia-smiDidukung oleh

Seperti terlihat, kita memiliki GPU RTX 3090 dengan versi CUDA 13. 

Python dan Jupyter

• Python 3.10+
• Jupyter Notebook atau JupyterLab (disarankan untuk eksperimen interaktif yang mudah)

pip install jupyterlab notebookDidukung oleh

Catatan: Kita menggunakan Jupyter Notebook sebagai lingkungan penulisan kode, yang memudahkan untuk bereksperimen, menjalankan inferensi langkah demi langkah, serta menghasilkan dan mengedit gambar secara iteratif langsung di dalam notebook.

2. Menginstal PyTorch dengan Dukungan CUDA

Pada langkah ini, kita menginstal PyTorch dengan dukungan CUDA agar inferensi berjalan di GPU, bukan CPU. Perintah di bawah menginstal PyTorch, TorchVision, dan TorchAudio dengan biner CUDA pra-kompilasi, sehingga tidak perlu membangun CUDA dari sumber.

!pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu130Didukung oleh

Setelah instalasi, PyTorch akan otomatis menggunakan GPU jika tersedia dan telah dikonfigurasi dengan benar.

3. Menginstal FLUX.2 dan dependensi yang diperlukan

Berikutnya, kita memasang pustaka inti yang diperlukan untuk menjalankan FLUX.2 secara lokal. Paket-paket ini menangani pemuatan model, inferensi, akselerasi GPU, kuantisasi, dan transfer data yang efisien.

!pip install -q diffusers transformers accelerate bitsandbytes huggingface_hub protobuf sentencepiece hf_transferDidukung oleh

Setelah terpasang, lingkungan Anda siap untuk memuat FLUX.2 dan mulai menjalankan inferensi pembuatan serta pengeditan gambar.

4. Memverifikasi dukungan GPU dan kuantisasi

Sebelum memuat FLUX.2, kita memverifikasi bahwa PyTorch dapat melihat GPU dan bahwa kuantisasi 4-bit didukung. Langkah ini penting untuk memastikan model dapat berjalan efisien dalam batas memori 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.")Didukung oleh

Keluaran mengonfirmasi bahwa PyTorch terpasang dengan benar dengan dukungan CUDA, GPU RTX 3090 Anda terdeteksi, dan bitsandbytes berfungsi dengan baik dengan kuantisasi 4-bit diaktifkan, sehingga sistem siap untuk inferensi GPU yang efisien.

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: PASSEDDidukung oleh

5. Memuat FLUX.2 dengan kuantisasi 4-bit

Pada langkah ini, kita memuat FLUX.2 [dev] menggunakan checkpoint 4-bit yang dikuantisasi untuk mengurangi penggunaan memori GPU sambil mempertahankan kualitas gambar yang tinggi. Ini penting untuk menjalankan model besar seperti FLUX.2 pada RTX 3090.

Kita mulai dengan mengimpor pustaka yang dibutuhkan dan mendefinisikan beberapa pengaturan kunci.

• repo_id menunjuk ke checkpoint FLUX.2 dev 4-bit.
• device memilih GPU Anda (perangkat CUDA pertama).
• torch_dtype menetapkan presisi komputasi yang digunakan saat inferensi. bfloat16 umum digunakan karena mengurangi memori dan dapat meningkatkan kecepatan sambil menjaga keluaran tetap stabil.

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.bfloat16Didukung oleh

Selanjutnya, kita memuat backbone transformer gambar FLUX.2 (komponen utama yang bertanggung jawab menghasilkan laten gambar) ke CPU terlebih dahulu. Ini menghindari penuhnya VRAM saat pemuatan awal dan memberi pipeline fleksibilitas lebih untuk memindahkan modul ke GPU hanya saat dibutuhkan.

transformer = Flux2Transformer2DModel.from_pretrained(
  repo_id, subfolder="transformer", torch_dtype=torch_dtype, device_map="cpu"
)Didukung oleh

Lalu kita memuat text encoder ke CPU juga. Text encoder mengonversi prompt Anda menjadi embedding yang memandu pembuatan gambar. Menjaganya di CPU saat penyiapan membantu menjaga memori GPU tetap longgar untuk bagian proses generasi yang lebih berat.

text_encoder = Mistral3ForConditionalGeneration.from_pretrained(
  repo_id, subfolder="text_encoder", dtype=torch_dtype, device_map="cpu"
)Didukung oleh

Terakhir, kita merakit penuh pipeline Diffusers dengan menyuntikkan transformer dan text encoder yang kita muat. 

Baris kunci di sini adalah enable_model_cpu_offload(): ini mengaktifkan offloading CPU ↔ GPU otomatis, artinya pipeline memindahkan bagian-bagian model ke GPU hanya saat benar-benar diperlukan, lalu memindahkannya kembali ke CPU setelahnya. Ini salah satu cara termudah untuk menjalankan model besar di GPU konsumen tanpa perlu mengelola penempatan perangkat secara manual.

pipe = Flux2Pipeline.from_pretrained(
  repo_id, transformer=transformer, text_encoder=text_encoder, torch_dtype=torch_dtype
)
pipe.enable_model_cpu_offload()Didukung oleh

6. Menjalankan pembuatan teks-ke-gambar pertama Anda

Sekarang kita siap menghasilkan gambar pertama menggunakan FLUX.2. Untuk tetap sederhana, kita mulai dengan satu prompt teks yang menggambarkan foto makro hiper-realistis seekor kumbang koksi.

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."
)
Didukung oleh

Selanjutnya, kita teruskan prompt ke pipeline dan jalankan inferensi.

• Kita menggunakan 28 langkah inferensi untuk menyeimbangkan kecepatan dan kualitas gambar.
• Skala panduan 4 menjaga hasil tetap natural tanpa terlalu memaksakan prompt.
• Seed acak tetap memastikan hasil yang dapat direproduksi.

image = pipe(
  prompt=prompt,
  generator=torch.Generator(device=device).manual_seed(42),
  num_inference_steps=28,
  guidance_scale=4,
).images[0]Didukung oleh

Untuk memantau berapa banyak memori GPU yang digunakan saat inferensi, buka terminal dan jalankan:

nvidia-smiDidukung oleh

Anda seharusnya melihat sekitar 21 GB VRAM GPU terpakai dengan utilisasi GPU tinggi, yang menunjukkan bahwa model menggunakan sumber daya yang tersedia secara efisien dan berjalan pada performa penuh di RTX 3090.

Setelah inferensi selesai, Anda dapat melihat gambar yang dihasilkan langsung di dalam Jupyter Notebook dengan cukup menampilkan objek gambar:

imageDidukung oleh

Hasilnya sangat detail dan realistis. Model mengikuti prompt dengan dekat sekaligus menambahkan detail subtil, seperti pencahayaan dan tekstur, yang tidak disebutkan secara eksplisit.

Terakhir, kita simpan gambar yang dihasilkan secara lokal:

output_path = "flux2_local_full.png"
image.save(output_path)
print(f"Image saved to {output_path}")Didukung oleh

Keluaran:

Image saved to flux2_local_full.pngDidukung oleh

7. Advanced prompting dengan JSON terstruktur

FLUX.2 mendukung teknik prompting lanjutan yang melampaui teks biasa, memungkinkan kontrol yang jauh lebih halus atas gambar akhir. Dengan prompt JSON terstruktur, Anda dapat secara eksplisit mendefinisikan tata letak adegan, subjek, pencahayaan, pengaturan kamera, suasana, bahkan palet warna menggunakan kode heksadesimal yang presisi.

Di bagian ini, kita menggunakan prompt JSON terstruktur untuk mendeskripsikan adegan secara detail. Alih-alih satu kalimat, kita mendefinisikan lingkungan, subjek, gaya, warna, pencahayaan, properti kamera, dan kendala negatif dalam format yang jelas dan terorganisir. 

Ini membantu FLUX.2 memahami instruksi yang kompleks dan menghasilkan keluaran yang lebih dapat diprediksi serta berkualitas tinggi.

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"
  ]
}
"""Didukung oleh

Lalu, kita jalankan inferensi dengan jumlah langkah yang lebih tinggi untuk menangkap lebih banyak detail sambil menjaga skala panduan tetap moderat agar tampak natural.

image_2 = pipe(
  prompt=advanced_prompt,
  generator=torch.Generator(device=device).manual_seed(42),
  num_inference_steps=50,
  guidance_scale=4,
).images[0]Didukung oleh

Untuk menampilkan gambar yang dihasilkan di dalam Jupyter Notebook:

image_2Didukung oleh

Gambar yang dihasilkan sangat mengikuti prompt terstruktur, menangkap adegan, suasana, pencahayaan, dan komposisi persis seperti yang ditentukan. 

8. Pengeditan gambar dengan FLUX.2 (image to image)

FLUX.2 juga mendukung pengeditan gambar, di mana sebuah gambar referensi digunakan sebagai dasar, dan model menerapkan perubahan yang dipandu oleh prompt teks. Ini sangat berguna ketika Anda ingin mempertahankan identitas, fitur wajah, dan rona kulit, sambil mengubah latar, suasana, atau lingkungan di sekitar subjek.

Untuk contoh ini, kita menggunakan foto seorang perempuan India dari Pexels.com sebagai gambar referensi:

Foto oleh cottonbro studio: https://www.pexels.com/photo/a-woman-with-a-nose-piercing-9317190/

Kita merancang prompt dengan cermat untuk menginstruksikan model agar menjaga wajah dan rona kulit alami perempuan tersebut tetap utuh, sambil mengubah latar, pencahayaan, dan ekspresi emosional. Tujuannya adalah mengedit gambar tanpa mengubah identitasnya.

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."
)Didukung oleh

Selanjutnya, kita memuat gambar referensi dan meneruskannya ke pipeline. FLUX.2 mendukung banyak gambar referensi, tetapi di sini kita menggunakan satu gambar untuk memandu pengeditan.

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]Didukung oleh

Untuk melihat hasil edit di dalam Jupyter Notebook:

image_3Didukung oleh

Keluaran sangat realistis. Model mempertahankan struktur wajah dan rona kulit perempuan tersebut sambil menempatkannya secara natural ke adegan baru dengan pencahayaan, suasana, dan latar yang berbeda. 

Hasilnya terasa bukan seperti editan AI, melainkan foto yang diambil fotografer profesional di lokasi dan momen berbeda.

Tips Optimasi Memori FLUX.2

Dari pengalaman saya, menjalankan FLUX.2 secara lokal menjadi andal hanya setelah beralih ke model 4-bit yang dikuantisasi dan menggunakan penyiapan berbasis kode dengan Transformers dan Diffusers. 

Sebelumnya, saya sering mengalami galat kehabisan memori pada RTX 3090 24 GB saat mencoba memuat terlalu banyak langsung ke CUDA. 

Alat UI seperti Stable Diffusion WebUI dan ComfyUI juga lebih mudah mencapai batas memori karena sering menyimpan buffer perantara tambahan, pratinjau, dan status alur kerja di memori, kecuali Anda menyetel opsi low-VRAM mereka dengan cermat.

Tips optimasi VRAM (yang benar-benar membantu saya):

• Gunakan checkpoint 4-bit (bitsandbytes) alih-alih bobot presisi penuh.
• Muat komponen di CPU terlebih dahulu (device_map="cpu") dan hindari mendorong semuanya ke CUDA sejak awal.
• Aktifkan offloading CPU–GPU (pipe.enable_model_cpu_offload()) agar hanya bagian aktif yang berada di GPU.
• Jaga langkah inferensi tetap wajar (misalnya, 28–35 langkah untuk run cepat; naikkan hanya bila diperlukan).
• Jaga skala panduan moderat (sekitar 3–5) untuk menghindari komputasi yang tidak perlu dan ketidakstabilan.
• Pantau VRAM secara langsung dengan nvidia-smi dan tutup aplikasi lain yang berat GPU.
• Jika masih terkena OOM, mulai ulang kernel notebook untuk benar-benar membersihkan memori GPU sebelum mencoba lagi.

Jika Anda masih menghadapi masalah kehabisan memori setelah mengikuti langkah-langkah ini, silakan lihat notebook DataLab ini untuk pemecahan masalah tambahan dan contoh optimasi memori.

Pemikiran Akhir

Saya benar-benar terkesan dengan sejauh apa model pembuatan gambar open-source telah berkembang. 

Model seperti FLUX.2 kini jelas kompetitif dengan sistem proprietari, baik dari sisi kualitas visual maupun pemahaman prompt. Dengan penyiapan yang tepat, sedikit eksperimen, dan sedikit optimasi memori, Anda bisa menghasilkan gambar berkualitas tinggi dan realistis secara lokal dan gratis, bahkan pada GPU konsumen.

Yang paling menonjol adalah tingkat kontrolnya. Advanced prompting, JSON terstruktur, pengeditan multi-referensi, dan alur kerja image-to-image memudahkan Anda melampaui generasi sederhana. 

Anda bisa menciptakan adegan sinematik, mengembangkan gambar untuk penceritaan, melakukan pengeditan gambar setara profesional, dan beriterasi dengan cepat tanpa bergantung pada platform tertutup. 

Bagi kreator, peneliti, dan pengembang, ini membuka banyak kebebasan berkreasi dan membuat pembuatan gambar kelas atas lebih mudah diakses dari sebelumnya.