Tutorial Qwen Image 2512: Bangun Poster Studio dengan Gradio

Qwen-Image-2512 adalah model text-ke-gambar open-source yang kuat yang sangat unggul untuk visual realistis dan komposisi dengan banyak teks. Dalam tutorial ini, kita akan menggunakannya untuk membangun Poster Studio, sebuah aplikasi Gradio tempat Anda memasukkan detail produk seperti nama, penawaran, harga, CTA, dan manfaat, memilih rasio aspek platform, lalu menghasilkan gambar promo hanya dengan satu klik.

Karena Qwen-Image-2512 adalah model besar, kita juga akan menekankan sisi praktis agar berjalan lancar. Anda akan mempelajari cara memuatnya secara stabil pada A100 dengan pengaturan presisi yang tepat, menghindari mode kegagalan umum, dan beradaptasi dengan alur kerja apa pun dengan beriterasi pada resolusi lebih kecil, mengurangi langkah, atau mengeksplorasi model terkuantisasi untuk perangkat keras yang lebih ketat.

Apa itu Qwen-Image-2512?

Qwen-Image-2512 adalah pembaruan untuk model fondasi text-ke-gambar Qwen, sekaligus lompatan kualitas dibandingkan rilis Qwen-Image sebelumnya. Di balik layar, Qwen-Image adalah model difusi MMDiT 20B, yang dirancang untuk kepatuhan prompt yang kuat dan perenderan teks di dalam gambar.

Model ini juga didukung oleh evaluasi gaya preferensi skala besar dengan 10.000+ putaran buta di AI Arena, di mana model ini menonjol sebagai model open-source terkuat sekaligus tetap kompetitif dengan sistem tertutup.

Tiga peningkatan yang paling berdampak dalam alur kerja nyata adalah:

• Potret manusia lebih realistis: Wajah terlihat kurang “AI-ish”, dengan fitur wajah lebih tajam, detail kulit lebih natural, dan realisme keseluruhan yang lebih baik.
• Tekstur alami lebih kaya: Adegan yang kaya tekstur seperti lanskap, air, bulu, dan material dirender dengan detail lebih halus dan mikro-tekstur yang lebih meyakinkan.
• Tipografi dan tata letak lebih kuat: Perenderan teks lebih akurat, dan komposisi lebih menyerupai halaman, yang sangat berguna untuk poster, slide, banner, dan infografik.

Proyek Contoh Qwen Image 2512: Bangun Poster Studio

Di bagian ini, kita akan membangun aplikasi Gradio sederhana yang:

• Mengumpulkan nama produk, deskripsi, penawaran, harga, CTA, dan manfaat
• Memungkinkan pengguna memilih preset platform seperti unggahan/cerita Instagram, banner, poster, atau slide
• Menyediakan panel untuk steps, true_cfg_scale, seed, dan negative prompt opsional.
• Terakhir, menghasilkan gambar poster menggunakan QwenImagePipeline.

Mari kita bangun selangkah demi selangkah.

Langkah 1: Prasyarat

Pertama, instal Diffusers terbaru dari GitHub (kartu model Qwen merekomendasikan ini untuk dukungan pipeline) beserta dependensi intinya:

!pip -q install --upgrade pip
!pip -q install git+https://github.com/huggingface/diffusers
!pip -q install transformers accelerate safetensors gradio pillow psutilDidukung oleh

Selanjutnya, lakukan pemeriksaan cepat untuk memastikan CUDA tersedia dan mengidentifikasi GPU:

import torch, diffusers
print("diffusers:", diffusers.__version__)
print("CUDA available:", torch.cuda.is_available())
!nvidia-smiDidukung oleh

Jika CUDA available: True dan Anda melihat GPU Anda di nvidia-smi, Anda siap memuat model.

Catatan: QwenImagePipeline bukan satu blok bergaya UNet. Di Diffusers, ini adalah tumpukan lengkap yang terdiri dari pengenkode teks Qwen2.5-VL-7B-Instruct, transformer difusi MMDiT, dan Variational Auto-Encoder(VAE) untuk decoding. Pengenkode teks 7B adalah salah satu alasan utama RAM/VRAM dapat melonjak saat pemuatan model dan generasi, terutama pada GPU yang lebih kecil. 

Saya menjalankan tutorial ini di Google Colab dengan A100, yang mampu menangani resolusi gambar 1328×1328 pada ~50 langkah dengan nyaman. Pada GPU kelas T4/16GB, Anda biasanya perlu menurunkan skala (sekitar resolusi gambar 768×768 dan langkah lebih sedikit) atau menggunakan varian terkuantisasi melalui runtime alternatif (seperti GGUF/ComfyUI).

Langkah 2: Impor dan utilitas dasar

Sebelum kita memuat model, ada baiknya menyiapkan kerangka runtime kecil agar Colab tetap dapat diprediksi. Qwen-Image-2512 berat, dan beban kerja pembuatan gambar dapat diam-diam menghabiskan RAM sistem dan memori GPU.

import os, gc, random, psutil, torch
from diffusers import QwenImagePipeline
import gradio as gr
os.environ["HF_HOME"] = "/content/hf"
os.makedirs("/content/hf", exist_ok=True)
def mem(tag=""):
    ram = psutil.virtual_memory().used / 1e9
    v_alloc = torch.cuda.memory_allocated()/1e9 if torch.cuda.is_available() else 0
    v_res   = torch.cuda.memory_reserved()/1e9 if torch.cuda.is_available() else 0
    print(f"[{tag}] RAM={ram:.1f}GB | VRAM alloc={v_alloc:.1f}GB reserved={v_res:.1f}GB")
def cleanup(tag="cleanup"):
    gc.collect()
    if torch.cuda.is_available():
        torch.cuda.empty_cache()
    mem(tag)
assert torch.cuda.is_available(), "GPU runtime required"
print("GPU:", torch.cuda.get_device_name(0))
torch.backends.cuda.matmul.allow_tf32 = True
torch.set_float32_matmul_precision("high")
cleanup("startup")Didukung oleh

Setelah dependensi terpasang, kita menyiapkan impor, cache, pemantauan memori, dan beberapa flag performa GPU. Berikut yang dilakukan kode di atas:

• QwenImagePipeline: Ini adalah kelas pipeline utama yang akan kita gunakan nanti untuk memuat dan menjalankan Qwen-Image-2512 dalam pembuatan gambar.
• gradio: Pustaka ini menjalankan UI web sederhana sehingga kita dapat membuat poster di dalam Colab.
• HF_HOME=/content/hf: Kita gunakan untuk mengikat cache Hugging Face ke folder yang pasti, sehingga unduhan model dan bobot tersimpan konsisten di berbagai run.
• Fungsi mem(): Fungsi mem() melacak RAM sistem dan VRAM GPU yang dialokasikan vs dicadangkan.
• Fungsi cleanup(): Utilitas reset kecil untuk membersihkan referensi Python dan melepaskan memori GPU yang di-cache, berguna saat beriterasi pada resolusi/langkah.
• Pemeriksaan GPU: Kita gagal cepat jika CUDA tidak tersedia, lalu mengaktifkan TF32 dan mengatur presisi matmul ke "high" untuk mempercepat perkalian matriks pada GPU Ampere seperti A100.

Penyiapan ini belum menghasilkan gambar, tetapi membuat langkah berikutnya (pemuatan dan inferensi) jauh lebih stabil dan mudah di-debug.

Langkah 3: Memuat Qwen-Image-2512 

Setelah runtime siap, saatnya memuat model ke dalam pipeline Diffusers. Pada A100, titik manisnya adalah menjalankan sebagian besar bobot dalam BF16 demi performa, namun mempertahankan decoding VAE di FP32 untuk menghindari NaN yang dapat muncul sebagai gambar hitam penuh.

DTYPE = torch.bfloat16 
pipe = QwenImagePipeline.from_pretrained(
    "Qwen/Qwen-Image-2512",
    torch_dtype=DTYPE,
    low_cpu_mem_usage=True,
    use_safetensors=True,
).to("cuda")
if hasattr(pipe, "vae") and pipe.vae is not None:
    pipe.vae.to(dtype=torch.float32)
cleanup("after pipe load")Didukung oleh

Berikut yang ingin kita capai pada kode di atas:

• Di GPU Ampere/Hopper (A100/H100), BF16 biasanya menjadi default terbaik karena lebih cepat dan lebih hemat memori daripada FP32, sekaligus lebih stabil secara numerik daripada FP16 untuk model besar.
• Selanjutnya, kita memuat pipeline Qwen-Image-2512 penuh dari Hugging Face dan menyatukan komponen model ke antarmuka yang dapat dipanggil. Kita menggunakan beberapa argumen kunci untuk ini:
• torch_dtype=DTYPE: Memuat sebagian besar bobot dalam BF16 untuk mengurangi VRAM dan mempercepat inferensi.
• low_cpu_mem_usage=True: Mengurangi duplikasi di sisi CPU saat pemuatan (penting untuk checkpoint besar).
• use_safetensors=True: Memastikan loader menggunakan format safetensors yang lebih aman/cepat bila tersedia.
• Terakhir, pipe.vae.to(torch.float32) mengonversi keluaran ruang laten menjadi piksel. Jika langkah decode itu terkena NaN/Inf pada presisi lebih rendah, gambar akhir bisa menjadi hitam seluruhnya. Jadi, kita paksa VAE ke FP32 lalu panggil cleanup() untuk mengonfirmasi jejak RAM/VRAM pasca-pemuatan.

Selanjutnya, kita akan mendefinisikan preset rasio aspek platform dan menyambungkan pipeline ke UI Gradio minimal untuk pembuatan poster interaktif.

Langkah 4: Preset dan fungsi pembuatan gambar

Sekarang kita membangun mesin demo, yaitu lapisan kecil yang mengubah input UI menjadi prompt yang terstruktur baik, memilih resolusi keluaran berdasarkan preset platform, dan memanggil pipeline Qwen Image untuk menghasilkan gambar.

ASPECT_PRESETS = {
    "Instagram Post (1:1) — 1328×1328": (1328, 1328),
    "Instagram Story (9:16) — 928×1664": (928, 1664),
    "YouTube / Banner (16:9) — 1664×928": (1664, 928),
    "Poster (3:4) — 1104×1472": (1104, 1472),
    "Slides (4:3) — 1472×1104": (1472, 1104),
    "Fast Draft (1:1) — 768×768": (768, 768),
}
DEFAULT_NEG = " " 
def build_prompt(product_name, product_desc, offer, price, cta, benefits, tone, style_keywords, language):
    return f"""
Create a high-converting e-commerce promotional poster in {language}. Clean grid layout, strong hierarchy.
- Product name: "{product_name}"
- Product description: "{product_desc}"
- Offer headline (exact): "{offer}"
- Price (exact): "{price}"
- CTA button text (exact): "{cta}"
- Benefits (use these exact phrases, no typos):
{benefits}
- Tone: {tone}
- Style keywords: {style_keywords}
- Text must be legible and correctly spelled.
- Do not add extra words, fake prices, or random letters.
- Align typography to a neat grid with consistent margins.
""".strip()
@torch.inference_mode()
def generate_image(product_name, product_desc, offer, price, cta, benefits, tone, style_keywords,
                   language, preset, negative_prompt, steps, true_cfg_scale, seed, show_seed):
    w, h = ASPECT_PRESETS[preset]
    prompt = build_prompt(product_name, product_desc, offer, price, cta, benefits, tone, style_keywords, language)
    if seed is None or int(seed) < 0:
        seed = random.randint(0, 2**31 - 1)
    seed = int(seed)
    gen = torch.Generator(device="cuda").manual_seed(seed)
    img = pipe(
        prompt=prompt,
        negative_prompt=negative_prompt,
        width=int(w),
        height=int(h),
        num_inference_steps=int(steps),
        true_cfg_scale=float(true_cfg_scale),
        generator=gen,
    ).images[0].convert("RGB")
    return (seed if show_seed else None), imgDidukung oleh

Peta preset dan dua fungsi di atas membentuk mesin inti Poster Studio kita.

• Kamus ASPECT_PRESETS mendefinisikan berbagai ukuran kanvas platform (misalnya 1:1 untuk unggahan Instagram, 9:16 untuk Story, 16:9 untuk banner). Pengguna cukup memilih preset, dan kita menerjemahkannya ke lebar × tinggi yang benar untuk generasi.
• Fungsi build_prompt() mengubah input produk sederhana seperti nama, penawaran, harga, CTA, dan manfaat menjadi brief gambar. Fungsi ini mempertimbangkan aturan tata letak dan teks, sehingga model mendapat batasan yang konsisten setiap kali dan tidak melenceng ke salinan acak.
• Fungsi generate_image() adalah lapisan eksekusi. Ia membaca preset yang dipilih untuk mendapatkan lebar/tinggi, dan memanggil pipeline Qwen-Image dengan steps, true_cfg_scale, dan negative_prompt yang dipilih. Terakhir, ia mengembalikan poster yang dihasilkan (dan opsional seed-nya). steps mengatur durasi proses difusi (semakin banyak langkah semakin lambat namun biasanya hasil lebih bersih), sedangkan true_cfg_scale mengatur seberapa kuat model mengikuti prompt (nilai lebih tinggi berarti kepatuhan lebih baik, tetapi terlalu tinggi dapat menimbulkan artefak).

Selanjutnya, kita akan menanamkan fungsi generate_image() ke antarmuka Gradio sehingga pengguna dapat membuat poster tanpa harus berurusan langsung dengan prompt engineering mentah.

Langkah 5: UI Gradio

Terakhir, kita membungkus mesin pembuatan poster dalam antarmuka Gradio. Aplikasi memungkinkan pengguna mengetik detail produk, memilih rasio aspek platform, dan menekan Generate.

with gr.Blocks(title="Qwen Poster Studio (Simple)") as demo:
    gr.Markdown("## Qwen Poster Studio — Qwen-Image-2512")
    with gr.Row():
        with gr.Column(scale=1):
            product_name = gr.Textbox(value="RÅSKOG Utility Cart", label="Product name")
            product_desc = gr.Textbox(value="Compact rolling cart for small spaces. Durable metal frame.", lines=2, label="Product description")
            offer = gr.Textbox(value="NEW YEAR SALE — 20% OFF", label="Offer headline")
            price = gr.Textbox(value="$29.99", label="Price")
            cta = gr.Textbox(value="Shop now", label="CTA button text")
            benefits = gr.Textbox(value="- Compact\n- Easy to move\n- Fits small spaces", lines=4, label="Benefits")
            tone = gr.Dropdown(["Premium", "Minimal", "Bold", "Playful", "Tech"], value="Premium", label="Tone")
            style_keywords = gr.Textbox(value="modern Scandinavian minimal, clean grid, soft warm lighting, premium product photography", label="Style keywords")
            language = gr.Dropdown(["English", "中文"], value="English", label="Language")
            preset = gr.Dropdown(list(ASPECT_PRESETS.keys()), value="Instagram Post (1:1) — 1328×1328", label="Platform preset")
            with gr.Accordion("Advanced (optional)", open=False):
                negative_prompt = gr.Textbox(value=DEFAULT_NEG, label="Negative prompt", lines=2)
                steps = gr.Slider(10, 80, value=50, step=1, label="Steps")
                true_cfg_scale = gr.Slider(1.0, 10.0, value=4.0, step=0.1, label="true_cfg_scale")
                seed = gr.Number(value=-1, precision=0, label="Seed (-1 = random)")
                show_seed = gr.Checkbox(value=False, label="Show seed in output")
            btn = gr.Button("Generate", variant="primary")
        with gr.Column(scale=1):
            used_seed_out = gr.Number(label="Used seed (optional)", precision=0)
            image_out = gr.Image(label="Generated poster")
    btn.click(
        fn=generate_image,
        inputs=[product_name, product_desc, offer, price, cta, benefits, tone, style_keywords,
                language, preset, negative_prompt, steps, true_cfg_scale, seed, show_seed],
        outputs=[used_seed_out, image_out]
    )
demo.launch(share=True, debug=True)Didukung oleh

Berikut cara kita membangun aplikasi Gradio:

• Kolom kiri mendefinisikan semua kontrol interaktif untuk brief poster. Pengguna mengisi kolom produk, lalu memilih nada, menambahkan kata kunci gaya, memilih bahasa, dan memilih preset platform. Preset penting karena dipetakan langsung ke lebar × tinggi final menggunakan ASPECT_PRESETS.
• Tombol “Advanced” mencakup parameter kunci seperti steps dan true_cfg_scale, yang masing-masing mengontrol berapa banyak iterasi denoising yang dijalankan model dan seberapa kuat model mengikuti prompt. Seed mengontrol reprodusibilitas, dan show_seed secara opsional menampilkan seed akhir.
• Sementara kolom kanan menampilkan gambar poster yang dihasilkan, dan opsional seed yang digunakan untuk generasi tersebut.
• Terakhir, pemanggilan btn.click() menghubungkan semuanya. Gradio mengambil semua widget input sesuai urutan, meneruskannya ke generate_image(), dan menyalurkan nilai yang dikembalikan ke widget output. Terakhir, demo.launch(share=True, debug=True) memulai server Gradio, memberi kita tautan publik yang dapat dibagikan untuk demo, dan mencetak log debug di notebook untuk membantu diagnosis masalah.

Berikut video yang menampilkan aplikasi Qwen Image 2512 final kita saat digunakan: