Qwen-Image-Edit-2509 Eğitimi: Stüdyo Düzeyinde Ürün Açıları Oluşturun

Tek başına satış yapanlar ve küçük markaların tam kapsamlı bir ürün fotoğraf çekimi için nadiren bütçesi olur. Bu rehberde, tek bir girdi görselini, Qwen-Image-Edit-2509 kullanarak e-ticarete hazır, çok açılı ürün render’larına (geniş, makro, ±45°, tepeden) dönüştüren ve tekrarlanabilir yapay zekâ ürün fotoğrafçılığı için LoRA tabanlı sanal kamera kontrolleri sunan bir Gradio uygulaması inşa edip çalıştıracağız.

Arka planda şunları kullanıyoruz:

• Temel model: Qwen/Qwen-Image-Edit-2509 (Apache-2.0)
• Açı kontrol LoRA’sı: dx8152/Qwen-Edit-2509-Multiple-angles
• İsteğe bağlı hız LoRA’sı: lightx2v/Qwen-Image-Lightning

Bu eğitimde şunları öğreneceksiniz:

• Qwen düzenleme hattını yüklemek ve birden çok LoRA’yı üst üste eklemek.
• Sağlam açı makrolarıyla kamera hareketlerini yönlendirmek.
• İçerik üreticileri ve e-ticaret ekipleri için sade bir Gradio arayüzü oluşturmak.
• Sonuçların tümünü kolay teslim için ZIP olarak dışa aktarmak.

Görüntü verisinin derin öğrenmede nasıl işlendiği hakkında daha fazla bilgi edinmek isterseniz Python ile Görüntü İşleme beceri yoluna göz atın. 

Neden Qwen Image Edit’i Multiple Angles LoRA ile Kullanmalı?

Qwen-Image-Edit-2509, Qwen’in görüntü düzenleme modelinin tutarlılığı ve çoklu görüntü düzenlemesi geliştirilmiş en yeni sürümüdür. Multiple-Angles LoRA, güvenilir “sanal kamera” kontrolleri ekler; böylece şunları söyleyebilirsiniz:

• 将镜头转为广角镜头 (geniş açıya geç)
• 将镜头转为特写镜头 (yakın plana geç)
• 将镜头向左旋转45度 (45° sola döndür)
• 将镜头转为俯视 (tepeden görünüm)

Bu komutlar, ürünü yeni bir ürüne hayal etmeden tutarlı biçimde yeniden kadrajlar.

Qwen Image Edit Adım Adım Eğitim: Ürün Çekimi Güçlendirici Oluşturma 

Bu rehberde, tek bir ürün görselini isteğe bağlı yaşam tarzı hazır ayarları ve hızlı önizleme modu ile stüdyo hazır bir açı setine (geniş, yakın plan, 45° sol/sağ ve tepeden gibi) dönüştüren bir uygulama kuracağız. Uygulama, Gradio arayüzüne sarılı Qwen/Qwen-Image-Edit-2509 modelini ve Multiple-Angles LoRA’yı kullanır.

Ortam kurulumundan model yüklemeye, üretim yardımcılarından web arayüzüne kadar ilerleyeceğiz.

Adım 1: Önkoşullar

Önce tüm çalışma zamanı bağımlılıklarını kurun. CUDA tekerlekleriyle PyTorch, Hugging Face araçları, Diffusers kütüphanesi, arayüz için Gradio ve görsel işlemede Pillow/OpenCV kullanıyoruz.

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/diffusersAltyapı:

Her önkoşulun yaptığı iş şudur:

• CUDA Tekerlekleri: PyTorch satırı, GPU hızlandırma için NVIDIA CUDA 12.1 tekerleklerine işaret eder.
• Transformers ve Diffusers: Transformers yapılandırmaları ve belirteçleyicileri yönetirken, Diffusers QwenImageEditPlusPipeline’ı sağlar.
• Safetensors: Güvenli bir tensör biçimi sunar (Pickle’dan daha hızlı ve daha güvenli).
• OpenCV-headless ve Pillow: Sağlam görsel G/Ç ve yeniden boyutlandırma sağlayarak ön/son işlemeyi destekler.
• Gradio: Yerelde ve Colab’da çalışan hızlı bir web arayüzüdür.

Ortam hazır olduğunda, Hugging Face’e kimlik doğrulaması yapabilir (isteğe bağlı) ve modelleri yükleyebiliriz.

Adım 2: Hugging Face kimlik doğrulaması

Bazı modeller veya adaptörler HuggingFace üzerinden kimlik doğrulaması gerektirebilir. Bu adım, oturum için bir kez giriş yapar.

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")Altyapı:

Önce HuggingFace hesabınıza giriş yapın ve hesap ayarlarınızda Erişim Jetonlarını bulun. Yeni jeton oluştur’a tıklayın ve Okuma türünde yeni bir jeton üretin. Gerekli izinleri seçin ve yeni jetonu oluşturun.

Canlı/Colab ortamlarında jetonları kod içine gömmeyin; bunun yerine ortam değişkenlerini veya Colab “Gizli Anahtarlar”ını kullanın.

Adım 3: Modeli yükleyin ve hattı kurun

Bu bölümde, Qwen-Image-Edit hattını kuruyor, açı LoRA’sını yüklüyor ve GPU farkındalıklı ayarlarla bir Hızlı geçişi ekliyoruz. Bu kodun yüksek RAM’li bir A100 GPU’da verimli çalıştığını unutmayın.

Adım 3.1:  İçe aktarmalar ve GPU yapılandırması

Şimdi temel kütüphaneleri içe aktaracağız ve hassasiyet, attention slicing ve VAE slicing’i kararlılık için otomatik ayarlamak üzere GPU’yu algılayacağız.

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),
}Altyapı:

Yukarıdaki kod bloklarının ana bileşenleri şunlardır:

• GPU otomatik yapılandırma (get_gpu_config işlevi): Mevcut hızlandırıcıyı algılarız ve cihazı (cpu/cuda), dtype’ı (GPU’da bfloat16 gibi) ve bellek davranışlarını seçmek için kullanılan küçük bir yapılandırma sözlüğü döndürürüz:
• CPU’da güvenlik için varsayılan olarak float32 kullanır ve attention/VAE slicing’i etkinleştiririz.
• T4 / <20 GB VRAM’de OOM’ları önlemek için bfloat16’yı korurken slicing’i etkinleştiririz.
• 20 GB+ GPU’larda (A100 gibi) slicing’i devre dışı bırakır ve hız için daha büyük yığınlara izin veririz.
• Model kimlikleri ve adaptörler: Qwen-Image-Edit-2509’u çekirdekteki düzenleyici olarak yükler, kamera kontrolü için Multiple-angles LoRA’yı ekler ve Hızlı Mod’a geçtiğinizde isteğe bağlı olarak Lightning LoRA’yı harmanlarız.  
• HF_BASE_MODEL = "Qwen/Qwen-Image-Edit-2509" ana görüntü düzenleme omurgasıdır.
• LORA_ANGLES = "dx8152/Qwen-Edit-2509-Multiple-angles" “sanal kamera” kontrolleri ekler.
• LORA_LIGHTNING = "lightx2v/Qwen-Image-Lightning" hızlı önizlemeler için isteğe bağlı bir hız adaptörüdür.

Not: HQ Modu için yalnızca açı adaptörü etkin kalır.

• Açı makroları: ANGLE_MACROS, “Wide-angle” veya “Top-down” gibi etiketleri, açı LoRA’sının güvenle anladığı eşdeğer Çince komutlara eşler. Bu komutlar, kimliği değiştirmeden sanal kamerayı (hareket/döndür/zoom) tutarlı biçimde hareket ettirir.
• Arka plan hazır ayarları: BACKGROUND_PRESETS, nihai isteme birleştirdiğimiz “mermer yüzey”, “yumuşak gri stüdyo” gibi kısa İngilizce parçacıklardır. Bunlar açı makrolarından bağımsızdır ve sahnenin kontrolünden sorumludur.
• En-boy oranları (ASPECT_RATIOS): Bunlar, tuval (1:1, 4:3, 16:9 vb.) üretmemize ve çıkışların üretim sonrası kırpmaya ihtiyaç duymaması için girdiyi çıkarıma geçmeden önce yeniden boyutlandırmamıza veya ortadan kırpmamıza olanak tanır.

Artık GPU ve adaptörler hazır. Şimdi Diffusers hattını başlatalım ve LoRA’ları ekleyelim.

Adım 3.2: Hat

Sırada, temel Qwen Edit hattını yüklüyor, GPU’ya göre bellek iyileştirmelerini etkinleştiriyor ve Multiple-Angles LoRA’yı üst üste ekliyoruz. Ayrıca hızlı önizlemeler için isteğe bağlı olarak Lightning LoRA’yı ekleyen bir mod anahtarı uyguluyoruz.

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)Altyapı:

Yukarıdaki kod, Ürün Çekimi Güçlendirici uygulaması için hat kurulum katmanıdır ve şu işlevleri yerine getirir:

• Hat başlatma: QwenImageEditPlusPipeline’ı temel modelden (Qwen/Qwen-Image-Edit-2509) oluşturur, algılanan cihaza (CPU/GPU) taşır ve donanımınıza göre tensör hassasiyetini (torch_dtype) ayarlar.
• Bellek güvenliği: Daha küçük GPU’larda, tepe VRAM’i düşürmek ve bellek taşmalarından kaçınmak için attention ve VAE slicing’i etkinleştirir; bunun karşılığında az miktarda hız fedakârlığı yapılır.
• LoRA bileşimi: Tekrarlanabilir “sanal kamera” kontrolleri (hareket/döndür/zoom) sağlamak için Multiple-angles LoRA’yı yükler ve isteğe bağlı olarak daha hızlı önizlemeler için Lightning LoRA’yı harmanlar.
• Mod değiştirme mantığı: set_pipeline_mode() yardımcı işlevi ve current_mode bayrağı, gereksiz Lightning yeniden yüklemelerini önleyerek HQ ile Hızlı durumlarını yönetir ve adaptörler arasında geçiş yapmanızı sağlar.

Hat artık hazır. Şimdi üretim işlevlerini ve Gradio arayüzünü bağlayalım.

Adım 4: Üretim işlevleri

Üretim işlevleri, istemleri oluşturarak, hedef en-boy oranına yeniden boyutlandırarak, seçili açılar boyunca hattı çalıştırarak ve sonuçları indirilebilir bir zip dosyasında paketleyerek üretimi gerçekleştirir.

Adım 4.1: İstem Birleştirici ve  Görsel Yeniden Boyutlandırma Yardımcıları

Modeli çağırmadan önce, iki durumsuz yardımcıyla girdileri normalize ederiz:

• compose_prompt() işlevi: Bu işlev, kamera açısı, arka plan hazır ayarı, özel sahne ve stil notlarından tek bir talimat dizesi oluşturur. Özlü cümlecikler, Qwen’in talimat ayrıştırmasını dengede tutar ve herhangi bir kısmın aşırı ağırlık kazanmasını önler.
• resize_image() işlevi: Kaynağı, kapsayacak şekilde ölçekleme stratejisiyle hedef en-boy oranına sığdırır; Lanczos yeniden örnekleme, yüksek kaliteli aşağı/yukarı ölçeklemede yardımcı olur ve merkez kırpma, ana konunun kadrajda kalmasını sağlar.

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 imgAltyapı:

Yukarıdaki iki işlev şu görevleri yerine getirir:

• Birleştirilebilir istem: Bölümleri " | " ile birleştiririz; bu, cümlecikleri görsel olarak ayırt ederken Qwen-Edit noktalama işaretlerini yönetir ve son cümleye taraf olmadan tutarlı bir ayrıştırma üretir. Kullanıcı metninde boş parçaları önlemek için .strip() kullanırız.
• Kapsayacak-ölçek matematiği: Bu, yeniden boyutlandırılmış görselin hedef tuvali her iki boyutta da tamamen kaplamasını garanti eder.
• Lanczos yeniden örnekleme: Aşağı örneklemede ince ayrıntıları koruyan ve yukarı ölçeklemede kıvrımlaşmayı azaltan yüksek kaliteli bir filtredir.
• Merkez kırpma: Yeniden boyutlandırmadan sonra, tipik kompozisyonu korumak ve beklenmedik kaymaların önüne geçmek için tam hedef tuvali ortadan kırparız.

Yardımcılar hazır olduğuna göre, şimdi çok açılı üretim döngüsünü çalıştırabilir ve sonuçları paketleyebiliriz.

Adım 4.2: Görselleri üretin 

Sırada, girdileri doğrular, görseli seçilen en-boy oranına uyarlar, seçili açılar üzerinde döngüye girer ve hattı inference_mode içinde çalıştırırız. Son olarak, üretilen tüm görselleri içeren bir zip dosyası döndürürüz.

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_pathAltyapı:

generate_images() işlevi, çok açılı üretimi ve dışa aktarmayı şu şekilde uygular:

• Doğrula, normalleştir ve yapılandır: Yüklenen bir görsel ve seçilen açıları kontrol eder, ardından görseli seçilen en-boy oranına uydurur (yeniden boyutlandırma ve ortadan kırpma) ve set_pipeline_mode(use_lightning) ile HQ ve Hızlı mod arasında geçiş yapar. 
• Verimli çıkarım: Her açı için, açı makrosu, arka plan hazır ayarı, sahne ve stili içeren tek bir talimat dizesi oluşturur. Ardından Diffusers girdilerini hazırlar ve belleği korumak için torch.inference_mode() altında yürütür. Düşük VRAM’li GPU’larda (T4 gibi), açı başına torch.cuda.empty_cache() çağrıları parçalanmayı azaltmaya yardımcı olur.
• Sonuçları UI geri bildirimiyle biriktir: Son olarak, her açı tamamlandığında Gradio ilerlemesini günceller ve tüm çıktıları aşağı akışta ziplemek üzere tek bir listede toplar.

create_zip(images) işlevi, kısa bir manifest.txt ile birlikte görüntüleri bellek içi (BytesIO) üzerinden kodlayarak kayıpsız dosyalar halinde bir zip dosyası yazar ve görsel yoksa None döndürür.

Üretim ve paketleme tamamlandığında, arayüz tek tıkla tüm açı paketini indirebileceğiniz çok açılı bir geçiş başlatabilir.

Adım 5: Gradio Arayüzü

Bu arayüz, kullanıcıların bir ürün görseli yüklemesine, açıları ve en-boy oranlarını seçmesine, bir arka plan hazır ayarı belirlemesine, stil notları girmesine ve hareket hâlindeyken birden çok açılı görseller üretmesine olanak tanır. 

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)Altyapı:

Yukarıdaki kod, tek bir üret eylemini çıkarıma bağlayan ve paylaşılabilir bir web arayüzü sunan etkileşimli bir Gradio uygulaması oluşturur; bunun için şunları kullanır:

• Girdiler (sol sütun): Sol panel, modelin ihtiyaç duyduğu her şeyi toplar: ürün fotoğrafı yüklemek için gr.Image, kamera açıları için gr.CheckboxGroup, en-boy oranı ve arka plan hazır ayarları için iki gr.Dropdown ve görünümü ince ayarlamak için özel sahne ve stil notlarına yönelik iki gr.Textbox.
• Çıktılar (sağ sütun): Bir gr.Gallery yöntemi, tüm üretilen açıları bir ızgarada göstererek kompozisyonları bir bakışta karşılaştırmanızı sağlar; gr.File bileşeni, hızlı indirme için PNG’lerin ZIP’ini sunar.
• Gelişmiş ayarlar : Bir gr.Checkbox, T4 sınıfı GPU’larda hızlı önizlemeler için Hızlı Modu (Lightning LoRA) açıp kapatır; Tohum ve Adımlar, yeniden üretilebilirliği ve kalite/zaman dengesini ayarlar. Guidance ve True-CFG, düzenleme gücünü kimlik kararlılığına karşı yönlendirir; Images per Angle ise tek seferde her kamera makrosu için birden fazla varyant üretmenizi sağlar.
• Arayüz kablolaması (eylem): Tek bir Generate düğmesi, tüm girdileri generate_images() işlevine (seçili adaptörlerle Qwen Edit’i çalıştırır) ve ardından create_zip() işlevine (çıktıları paketler) bağlar; arayüze hem galeriyi hem de ZIP’i geri döndürür.
• Uygulama başlatma: Son olarak, demo.launch() yöntemi web uygulamasını ayağa kaldırır ve herkese açık bir paylaşım URL’si sağlar—Colab oturumları, hızlı demolar veya paydaşlara aracı kendilerinin denemesi için bağlantı göndermek adına idealdir.

Son olarak Generate’e tıklayın ve tam açılı paketin render edildiğini izleyin. 

İşte bu modelle yaptığım deneylerin sonuçları. Önce, ayarlanan farklı parametrelere göre ürünlerin nasıl görüntülendiğini görebilirsiniz.