Tutorial Qwen-Image-Edit-2509: Hasilkan Sudut Produk Siap Studio

Penjual mandiri dan brand kecil jarang memiliki anggaran untuk pemotretan produk lengkap. Dalam panduan ini, kita akan membangun dan menjalankan aplikasi Gradio yang mengubah satu gambar input menjadi render produk multi-sudut siap e-commerce (wide, makro, ±45°, top-down) menggunakan Qwen-Image-Edit-2509 dengan kontrol kamera virtual berbasis LoRA untuk fotografi produk AI yang dapat direproduksi.

Di balik layar, kita menggunakan:

• Model dasar: Qwen/Qwen-Image-Edit-2509 (Apache-2.0)
• LoRA kontrol sudut: dx8152/Qwen-Edit-2509-Multiple-angles
• LoRA kecepatan opsional: lightx2v/Qwen-Image-Lightning

Dalam tutorial ini, Anda akan mempelajari cara:

• Memuat pipeline edit Qwen dan menumpuk beberapa LoRA.
• Menggerakkan kamera dengan makro sudut yang andal.
• Membangun UI Gradio yang rapi untuk kreator dan tim e-niaga.
• Mengekspor semua hasil sebagai ZIP untuk serah terima yang mudah.

Jika Anda ingin mempelajari lebih lanjut tentang cara data gambar diproses dalam deep learning, lihat Image Processing in Python skill track. 

Mengapa Menggunakan Qwen Image Edit dengan Multiple Angles LoRA?

Qwen-Image-Edit-2509 adalah iterasi terbaru dari model pengeditan gambar Qwen dengan konsistensi yang ditingkatkan dan pengeditan multi-gambar. Multiple-Angles LoRA menyuntikkan kontrol “kamera virtual” yang andal sehingga Anda dapat mengatakan:

• 将镜头转为广角镜头 (ubah ke wide-angle)
• 将镜头转为特写镜头 (ubah ke close-up)
• 将镜头向左旋转45度 (putar 45° ke kiri)
• 将镜头转为俯视 (tampilan top-down)

Perintah-perintah ini secara konsisten membingkai ulang produk yang sama tanpa berhalusinasi menjadi produk baru.

Tutorial Qwen Image Edit Langkah demi Langkah: Membangun Product Shot Booster 

Dalam panduan ini, kita akan membangun aplikasi yang mengubah satu gambar produk menjadi satu set sudut siap studio (termasuk sudut seperti wide, close-up, 45° kiri/kanan, dan top-down), dengan preset gaya hidup opsional dan mode pratinjau cepat. Aplikasi ini menggunakan model Qwen/Qwen-Image-Edit-2509 dan Multiple-Angles LoRA yang dibungkus dalam UI Gradio.

Kita akan mulai dari penyiapan lingkungan hingga pemuatan model, helper generasi, dan UI web.

Langkah 1: Prasyarat

Pertama, instal semua dependensi runtime. Kita menggunakan PyTorch dengan roda CUDA, tooling Hugging Face, pustaka Diffusers, Gradio untuk UI, dan Pillow/OpenCV untuk penanganan gambar.

pip install -q torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
pip install -q transformers>=4.44.0 accelerate>=0.33.0 safetensors>=0.4.3
pip install -q pillow>=10.2.0 huggingface_hub>=0.24.0 opencv-python-headless>=4.9.0.80
pip install -q numpy>=1.26.0 gradio>=4.0.0
pip install -q git+https://github.com/huggingface/diffusersDidukung oleh

Berikut fungsi masing-masing prasyarat:

• CUDA Wheels: Baris PyTorch menunjuk ke roda NVIDIA CUDA 12.1 untuk akselerasi GPU.
• Transformers dan Diffusers: Transformers mengelola konfigurasi dan tokenizer, sementara Diffusers menyediakan QwenImageEditPlusPipeline.
• Safetensors: Menyediakan format tensor yang aman (lebih cepat dan lebih aman daripada Pickle).
• OpenCV-headless dan Pillow: Menyediakan I/O gambar yang andal dan pengubahan ukuran untuk pra/pasca-pemrosesan.
• Gradio: UI web cepat yang bekerja secara lokal maupun di Colab.

Setelah lingkungan siap, kita bisa melakukan autentikasi ke Hugging Face (opsional) dan memuat model.

Langkah 2: Autentikasi Hugging Face

Beberapa model atau adapter mungkin memerlukan autentikasi dari HuggingFace. Langkah ini akan masuk satu kali untuk sesi.

from huggingface_hub import login
import os
HF_TOKEN = "Your_HF_Token"  # @param {type:"string"}
if HF_TOKEN:
    login(token=HF_TOKEN)
    print("Logged in to Hugging Face")
else:
    print("WARNING: No token provided. Continuing without authentication")Didukung oleh

Mulailah dengan masuk ke akun HuggingFace Anda dan cari Access Tokens di pengaturan akun. Klik Create new token dan buat token baru dengan tipe Read. Pilih izin yang diperlukan dan buat token baru.

Di produksi/Colab, jangan hardcode token; gunakan variabel lingkungan atau “Secrets” Colab.

Langkah 3: Memuat model dan menyiapkan pipeline

Di bagian ini, kita menyiapkan pipeline Qwen-Image-Edit, memuat LoRA sudut, dan menambahkan toggle Fast dengan pengaturan yang menyesuaikan GPU. Perlu dicatat bahwa kode ini berjalan efisien pada GPU A100 dengan RAM tinggi.

Langkah 3.1:  Impor dan konfigurasi GPU

Sekarang, kita akan mengimpor pustaka inti dan mendeteksi GPU untuk mengatur presisi, attention slicing, dan VAE slicing secara otomatis demi stabilitas.

import io
import zipfile
from typing import List, Tuple, Optional
import gc
import torch
from PIL import Image
from diffusers import QwenImageEditPlusPipeline
import gradio as gr
def get_gpu_config():
    if not torch.cuda.is_available():
        return {
            'device': 'cpu',
            'dtype': torch.float32,
            'gpu_name': 'CPU',
            'vram_gb': 0,
            'max_batch': 1,
            'enable_attention_slicing': True,
            'enable_vae_slicing': True,
        }
    gpu_name = torch.cuda.get_device_name(0)
    vram_gb = torch.cuda.get_device_properties(0).total_memory / 1e9 
    if 'T4' in gpu_name or vram_gb < 20:
        return {
            'device': 'cuda',
            'dtype': torch.bfloat16,
            'gpu_name': gpu_name,
            'vram_gb': vram_gb,
            'max_batch': 1,
            'enable_attention_slicing': True,
            'enable_vae_slicing': True,
        }
    else:
        return {
            'device': 'cuda',
            'dtype': torch.bfloat16,
            'gpu_name': gpu_name,
            'vram_gb': vram_gb,
            'max_batch': 2,
            'enable_attention_slicing': False,
            'enable_vae_slicing': False,
        }
gpu_config = get_gpu_config()
HF_BASE_MODEL = "Qwen/Qwen-Image-Edit-2509"
LORA_ANGLES = "dx8152/Qwen-Edit-2509-Multiple-angles"
LORA_LIGHTNING = "lightx2v/Qwen-Image-Lightning"
ANGLE_MACROS = {
    "Wide-angle": "将镜头转为广角镜头",
    "Close-up": "将镜头转为特写镜头",
    "Forward": "将镜头向前移动",
    "Left": "将镜头向左移动",
    "Right": "将镜头向右移动",
    "Down": "将镜头向下移动",
    "Rotate 45° Left": "将镜头向左旋转45度",
    "Rotate 45° Right": "将镜头向右旋转45度",
    "Top-down": "将镜头转为俯视",
}
BACKGROUND_PRESETS = {
    "(None)": None,
    "Pure Studio (white seamless)": "in a professional studio with seamless white background, soft shadows, product centered",
    "Soft Gray Studio": "in a professional studio with seamless soft gray background, gentle vignette, softbox lighting",
    "Lifestyle (cozy desk)": "on a cozy wooden desk near a window, soft natural light, minimal props",
    "Lifestyle (marble)": "on a clean white marble surface, bright daylight, subtle reflections",
    "Lifestyle (outdoor)": "outdoors on a neutral table, soft shade, bokeh background",
}
ASPECT_RATIOS = {
    "1:1 (Square)": (1024, 1024),
    "4:3 (Standard)": (1024, 768),
    "3:4 (Portrait)": (768, 1024),
    "16:9 (Widescreen)": (1024, 576),
    "9:16 (Mobile)": (576, 1024),
    "3:2 (Photo)": (1024, 683),
    "2:3 (Portrait Photo)": (683, 1024),
}Didukung oleh

Berikut komponen kunci dari blok kode di atas:

• Konfigurasi otomatis GPU (fungsi get_gpu_config): Kita mendeteksi akselerator yang tersedia dan mengembalikan kamus konfigurasi kecil yang digunakan untuk memilih device (cpu/cuda), dtype (seperti bfloat16 di GPU), dan perilaku memori:
• Di CPU, default ke float32 dan aktifkan attention/VAE slicing demi keamanan.
• Di T4 / <20 GB VRAM, tetap bfloat16 namun aktifkan slicing untuk mencegah OOM.
• Di GPU 20 GB+ (seperti A100), nonaktifkan slicing dan izinkan batch lebih besar untuk kecepatan.
• ID model dan adapter: Kita memuat Qwen-Image-Edit-2509 sebagai editor inti, bersama Multiple-angles LoRA untuk kontrol kamera, dan opsional mencampur Lightning LoRA saat Anda mengaktifkan Fast Mode.  
• HF_BASE_MODEL = "Qwen/Qwen-Image-Edit-2509" adalah tulang punggung pengeditan gambar utama.
• LORA_ANGLES = "dx8152/Qwen-Edit-2509-Multiple-angles" menambahkan kontrol “kamera virtual”.
• LORA_LIGHTNING = "lightx2v/Qwen-Image-Lightning" adalah adapter kecepatan opsional untuk pratinjau cepat.

Catatan: untuk HQ Mode, hanya adapter sudut yang tetap aktif.

• Makro sudut: ANGLE_MACROS memetakan label seperti “Wide-angle” atau “Top-down” ke perintah bahasa Mandarin ekuivalen yang dapat dipahami LoRA sudut dengan andal. Perintah ini secara konsisten menggerakkan kamera virtual (gerak/putar/zoom) tanpa mengubah identitas.
• Preset latar belakang: BACKGROUND_PRESETS adalah fragmen bahasa Inggris singkat seperti “marble surface”, “soft gray studio”, yang kita gabungkan ke prompt akhir. Ini terpisah dari makro sudut dan bertugas mengontrol suasana/adegan.
• Rasio aspek (ASPECT_RATIOS): Memungkinkan kita menghasilkan kanvas (1:1, 4:3, 16:9, dll.) dan mengubah ukuran atau center-crop input sebelum inferensi sehingga output tidak memerlukan pemotongan pascaproduksi.

GPU dan adapter kini siap. Mari kita instantiate pipeline Diffusers dan menautkan LoRA selanjutnya.

Langkah 3.2: Pipeline

Selanjutnya, kita memuat pipeline Qwen Edit dasar, mengaktifkan optimasi memori sesuai GPU, dan menumpuk Multiple-Angles LoRA. Kita juga mengimplementasikan sakelar mode untuk menambahkan Lightning LoRA secara opsional untuk pratinjau cepat.

pipe = QwenImageEditPlusPipeline.from_pretrained(
    HF_BASE_MODEL,
    torch_dtype=gpu_config['dtype'],
)
pipe = pipe.to(gpu_config['device'])
if gpu_config['enable_attention_slicing']:
    pipe.enable_attention_slicing()
if gpu_config['enable_vae_slicing']:
    pipe.enable_vae_slicing()
pipe.load_lora_weights(LORA_ANGLES, adapter_name="angles")
current_mode = {"fast": False}
def set_pipeline_mode(use_lightning: bool):
    global current_mode  
    if use_lightning and not current_mode["fast"]:
        pipe.load_lora_weights(LORA_LIGHTNING, adapter_name="lightning")
        pipe.set_adapters(["angles", "lightning"], adapter_weights=[1.0, 1.0])
        current_mode["fast"] = True
    elif not use_lightning and current_mode["fast"]:
        pipe.set_adapters(["angles"], adapter_weights=[1.0])
        current_mode["fast"] = False
    elif not use_lightning and not current_mode["fast"]:
        pipe.set_adapters(["angles"], adapter_weights=[1.0])
set_pipeline_mode(False)Didukung oleh

Kode di atas adalah lapisan penyiapan pipeline untuk aplikasi Product Shot Booster, yang melakukan fungsi berikut:

• Inisialisasi pipeline: Menginstansiasi QwenImageEditPlusPipeline dari model dasar (Qwen/Qwen-Image-Edit-2509), memindahkannya ke device terdeteksi (CPU/GPU), dan mengatur presisi tensor (torch_dtype) berdasarkan perangkat keras Anda.
• Keamanan memori: Pada GPU yang lebih kecil, mengaktifkan attention dan VAE slicing untuk mengurangi puncak VRAM dan menghindari kesalahan kehabisan memori dengan menukar sedikit kecepatan demi stabilitas.
• Komposisi LoRA: Memuat Multiple-angles LoRA untuk menyediakan kontrol “kamera virtual” yang berulang (gerak/putar/zoom) dan secara opsional mencampur Lightning LoRA untuk pratinjau yang lebih cepat.
• Logika pergantian mode: Fungsi helper set_pipeline_mode() dan flag current_mode mengelola status HQ vs Fast, mencegah pemuatan ulang Lightning yang berulang serta memungkinkan Anda mengganti adapter.

Sekarang pipeline siap. Mari lanjutkan ke fungsi generasi dan UI Gradio.

Langkah 4: Fungsi generasi

Fungsi generasi menyusun prompt, mengubah ukuran ke rasio aspek target, menjalankan pipeline untuk sudut yang dipilih, dan mengemas hasil untuk diunduh dalam file zip.

Langkah 4.1: Prompt Composer dan Helper Ubah Ukuran Gambar

Sebelum memanggil model, kita menormalkan input dengan dua helper stateless:

• compose_prompt() function: Fungsi ini menyusun satu string instruksi dari sudut kamera, preset latar, adegan kustom, dan catatan gaya. Klausa yang ringkas membantu menjaga parsing instruksi Qwen tetap stabil dan menghindari pembobotan berlebihan pada satu bagian.
• resize_image() function: Menyesuaikan gambar sumber ke rasio aspek target menggunakan strategi scale-to-cover, resampling Lanczos membantu untuk down/up-scaling berkualitas tinggi, serta center crop agar subjek utama tetap dalam bingkai.

def compose_prompt(angle_phrase: str,
                   bg_preset_text: Optional[str],
                   custom_scene: str,
                   extra_style: str) -> str:
    parts = [angle_phrase]
    if bg_preset_text:
        parts.append(f"{bg_preset_text}")
    if custom_scene.strip():
        parts.append(custom_scene.strip())
    if extra_style.strip():
        parts.append(extra_style.strip())
    return " | ".join(parts)
def resize_image(img: Image.Image, target_size: Tuple[int, int]) -> Image.Image:
    target_w, target_h = target_size
    orig_w, orig_h = img.size
    scale = max(target_w / orig_w, target_h / orig_h)
    new_w = int(orig_w * scale)
    new_h = int(orig_h * scale)
    img = img.resize((new_w, new_h), Image.Resampling.LANCZOS) 
    left = (new_w - target_w) // 2
    top = (new_h - target_h) // 2
    img = img.crop((left, top, left + target_w, top + target_h))    
    return imgDidukung oleh

Dua fungsi di atas melakukan tugas berikut:

• Prompt yang dapat dikomposisi: Kita menggabungkan bagian dengan " | " agar klausa terlihat jelas, sementara Qwen-Edit menangani tanda baca dan menghasilkan parsing yang konsisten tanpa bias ke klausa terakhir. Kita juga menggunakan .strip() pada teks pengguna untuk menghindari fragmen kosong.
• Matematika scale-to-cover: Menjamin gambar yang diubah ukuran sepenuhnya menutupi kanvas target di kedua dimensi.
• Resampling Lanczos: Filter berkualitas tinggi yang menjaga detail halus saat downsampling dan mengurangi aliasing saat upscaling.
• Center crop: Setelah mengubah ukuran, kita memotong kanvas target tepat dari tengah untuk mempertahankan komposisi umum dan menghindari potongan tidak terduga di luar pusat.

Dengan helper siap, kita kini dapat menjalankan loop generasi multi-sudut dan mengemas hasilnya.

Langkah 4.2: Menghasilkan gambar 

Berikutnya, kita memvalidasi input, menyesuaikan gambar ke rasio aspek yang dipilih, melakukan loop atas sudut yang dipilih, dan menjalankan pipeline dalam inference_mode. Terakhir, kita mengembalikan file zip berisi semua gambar yang dihasilkan.

def generate_images(
    source_img: Image.Image,
    angle_keys: List[str],
    bg_key: str,
    custom_scene: str,
    extra_style: str,
    aspect_ratio: str,
    use_lightning: bool,
    seed: int,
    steps: int,
    guidance_scale: float,
    true_cfg_scale: float,
    images_per_prompt: int,
    progress=gr.Progress()
) -> List[Image.Image]:   
    if source_img is None:
        return [], "WARNING: Please upload an image first!"    
    if not angle_keys:
        return [], "WARNING: Please select at least one angle!"  
    target_size = ASPECT_RATIOS[aspect_ratio]
    source_img = resize_image(source_img, target_size)  
    set_pipeline_mode(use_lightning)
    results = []
    generator = torch.manual_seed(seed)  
    bg_preset_text = BACKGROUND_PRESETS.get(bg_key)    
    total_angles = len(angle_keys)    
    for idx, angle_name in enumerate(angle_keys):
        progress((idx + 1) / total_angles, f"Generating {angle_name}...") 
        angle_phrase = ANGLE_MACROS[angle_name]
        full_prompt = compose_prompt(angle_phrase, bg_preset_text, custom_scene, extra_style)   
        inputs = {
            "image": [source_img],
            "prompt": full_prompt,
            "generator": generator,
            "true_cfg_scale": true_cfg_scale,
            "negative_prompt": " ",
            "num_inference_steps": steps,
            "guidance_scale": guidance_scale,
            "num_images_per_prompt": images_per_prompt,
            "height": target_size[1],
            "width": target_size[0],
        }     
        with torch.inference_mode():
            out = pipe(**inputs)   
        for img_idx, im in enumerate(out.images):
            results.append(im) 
        if 'T4' in gpu_config['gpu_name']:
            torch.cuda.empty_cache()
    return results
def create_zip(images: List[Image.Image]) -> Optional[str]:
    if not images:
        return None
    zip_path = "/content/product_shot_booster.zip"
    with zipfile.ZipFile(zip_path, mode="w", compression=zipfile.ZIP_DEFLATED) as zf:
        zf.writestr("manifest.txt", "Product Shot Booster Export\nGenerated angles exported as PNG files.\n")
        for idx, img in enumerate(images):
            buf = io.BytesIO()
            img.save(buf, format="PNG")
            zf.writestr(f"angle_{idx+1:03d}.png", buf.getvalue())
    return zip_pathDidukung oleh

Fungsi generate_images() mengimplementasikan generasi multi-sudut dan ekspor dengan cara:

• Validasi, normalisasi, dan konfigurasi: Memeriksa gambar yang diunggah dan sudut yang dipilih, lalu menyesuaikan gambar ke rasio yang dipilih (ubah ukuran dan center crop), serta mengganti mode HQ vs Fast melalui set_pipeline_mode(use_lightning). 
• Inferensi efisien: Untuk tiap sudut, menyusun satu string instruksi termasuk makro sudut, preset latar, adegan, dan gaya. Kemudian menyiapkan input Diffusers dan menjalankan di bawah torch.inference_mode() untuk menghemat memori. Pada GPU VRAM rendah (seperti T4), pemanggilan torch.cuda.empty_cache() per sudut membantu mengurangi fragmentasi.
• Mengagregasi hasil dengan umpan balik UI: Akhirnya memperbarui progres Gradio saat tiap sudut selesai dan mengumpulkan semua output dalam satu daftar untuk proses zipping berikutnya.

Fungsi create_zip(images) menyediakan ekspor portabel yang menulis file zip dengan manifest.txt singkat serta menyandi gambar melalui (BytesIO) dalam memori untuk file lossless dan mengembalikan None jika tidak ada gambar.

Dengan generasi dan pengemasan siap, UI dapat memicu proses multi-sudut dan menawarkan unduhan sekali klik untuk paket sudut lengkap.

Langkah 5: Gradio UI

UI ini memungkinkan pengguna mengunggah gambar produk, memilih sudut dan rasio aspek, memilih preset latar, menetapkan catatan gaya, dan menghasilkan gambar multi-sudut secara langsung. 

with gr.Blocks(title="Product Shot Booster", theme=gr.themes.Soft()) as demo:
    gr.Markdown("<h1 style='text-align: center;font-weight: bold;'>Product Shot Booster</h1>")
    with gr.Row():
        with gr.Column(scale=1):
            input_image = gr.Image(
                label="Product Image",
                type="pil",
                height=300
            ) 
            angle_choices = gr.CheckboxGroup(
                choices=list(ANGLE_MACROS.keys()),
                value=["Wide-angle", "Close-up", "Rotate 45° Left", "Rotate 45° Right", "Top-down"],
                label="Camera Angles"
            ) 
            aspect_ratio = gr.Dropdown(
                choices=list(ASPECT_RATIOS.keys()),
                value="1:1 (Square)",
                label="Aspect Ratio"
            )
            bg_preset = gr.Dropdown(
                choices=list(BACKGROUND_PRESETS.keys()),
                value="(None)",
                label="Background"
            ) 
            custom_scene = gr.Textbox(
                label="Custom Scene",
                placeholder="e.g., 'on a matte black table with soft reflections'",
                lines=2
            )    
            extra_style = gr.Textbox(
                label="Style Notes",
                value="studio-grade lighting, high clarity, ecommerce-ready composition",
                lines=2
            )
        with gr.Column(scale=2):
            output_gallery = gr.Gallery(
                  label="Generated Images",
                  show_label=True,
                  columns=3,
                  height="auto",
                  object_fit="contain"
              )

            info_output = gr.Markdown("")
            zip_output = gr.File(label="Download ZIP")
    with gr.Accordion("Advanced Settings", open=False):
        with gr.Row():
            use_lightning = gr.Checkbox(
                label="Fast Mode (Lightning LoRA)",
                value=('T4' in gpu_config['gpu_name']),
                info="Enable for faster generation (recommended for T4)"
            )   
            seed = gr.Number(
                label="Seed",
                value=123,
                precision=0
            )  
            steps = gr.Slider(
                label="Inference Steps",
                minimum=10,
                maximum=60,
                value=28,
                step=1
            )
        with gr.Row():
            guidance_scale = gr.Slider(
                label="Guidance Scale",
                minimum=0.0,
                maximum=8.0,
                value=1.0,
                step=0.1
            )
            true_cfg_scale = gr.Slider(
                label="True CFG Scale",
                minimum=0.0,
                maximum=10.0,
                value=4.0,
                step=0.1
            ) 
            images_per_prompt = gr.Slider(
                label="Images per Angle",
                minimum=1,
                maximum=4,
                value=1,
                step=1
            )
    generate_btn = gr.Button("Generate", variant="primary", size="lg")
    def generate_and_zip(*args):
      images = generate_images(*args)
      zip_file = create_zip(images) if images else None
      return images, zip_file 
    generate_btn.click(
        fn=generate_and_zip,
        inputs=[
            input_image,
            angle_choices,
            bg_preset,
            custom_scene,
            extra_style,
            aspect_ratio,
            use_lightning,
            seed,
            steps,
            guidance_scale,
            true_cfg_scale,
            images_per_prompt
        ],
        outputs=[output_gallery, zip_output]
    )
demo.launch(share=True, debug=True, show_error=True)Didukung oleh

Kode di atas membangun aplikasi Gradio interaktif yang menghubungkan satu aksi generate ke inferensi dan mengekspos UI web yang dapat dibagikan, dengan menggunakan:

• Input (kolom kiri): Panel kiri mengumpulkan semua yang dibutuhkan model menggunakan gr.Image untuk mengunggah foto produk, gr.CheckboxGroup untuk sudut kamera, dua gr.Dropdowns untuk rasio aspek dan preset latar, serta dua kolom gr.Textbox untuk adegan kustom dan catatan gaya guna menyetel tampilan.
• Output (kolom kanan): Metode gr.Gallery menampilkan semua sudut yang dihasilkan dalam grid sehingga Anda dapat membandingkan komposisi sekilas, dan komponen gr.File menawarkan ZIP berisi PNG untuk diunduh cepat.
• Pengaturan lanjutan: Sebuah gr.Checkbox mengaktifkan Fast Mode (Lightning LoRA) untuk pratinjau cepat pada GPU kelas T4, sementara Seed dan Steps menyesuaikan reprodusibilitas serta trade-off kualitas/waktu. Guidance dan True-CFG mengarahkan kekuatan edit versus stabilitas identitas, dan Images per Angle memungkinkan Anda menghasilkan beberapa varian per makro kamera sekaligus.
• Perangkaian antarmuka (aksi): Satu tombol Generate menghubungkan semua input ke fungsi generate_images() (yang menjalankan Qwen Edit dengan adapter yang dipilih) lalu ke fungsi create_zip() (yang mengemas output), mengembalikan galeri dan ZIP ke antarmuka.
• Peluncuran aplikasi: Terakhir, metode demo.launch() menjalankan aplikasi web dan menyediakan URL berbagi publik—ideal untuk sesi Colab, demo cepat, atau mengirim tautan kepada stakeholder agar mencoba alat ini sendiri.

Terakhir, klik Generate dan lihat satu paket sudut lengkap dirender. 

Berikut hasil dari eksperimen saya dengan model ini. Pertama, Anda dapat melihat bagaimana produk ditampilkan berdasarkan parameter yang ditetapkan.