Hướng dẫn Qwen-Image-Edit-2509: Tạo góc chụp sản phẩm chuẩn studio

Người bán đơn lẻ và các thương hiệu nhỏ hiếm khi có ngân sách cho một buổi chụp sản phẩm đầy đủ. Trong hướng dẫn này, chúng ta sẽ xây dựng và chạy một ứng dụng Gradio để biến một ảnh đầu vào thành các bản render sản phẩm sẵn sàng cho thương mại điện tử với nhiều góc nhìn (rộng, macro, ±45°, từ trên xuống) sử dụng Qwen-Image-Edit-2509 với điều khiển máy ảnh ảo dựa trên LoRA để chụp ảnh sản phẩm bằng AI có thể tái lập.

Bên dưới, chúng tôi sử dụng:

• Mô hình nền tảng: Qwen/Qwen-Image-Edit-2509 (Apache-2.0)
• LoRA điều khiển góc: dx8152/Qwen-Edit-2509-Multiple-angles
• LoRA tăng tốc (tùy chọn): lightx2v/Qwen-Image-Lightning

Trong hướng dẫn này, bạn sẽ học cách:

• Tải pipeline chỉnh sửa của Qwen và xếp chồng nhiều LoRA.
• Điều khiển chuyển động máy ảnh bằng các macro góc đáng tin cậy.
• Xây dựng UI Gradio gọn gàng cho nhà sáng tạo và đội thương mại điện tử.
• Xuất tất cả kết quả thành tệp ZIP để bàn giao dễ dàng.

Nếu bạn muốn hiểu sâu hơn về cách dữ liệu ảnh được xử lý trong học sâu, hãy xem lộ trình kỹ năng Xử lý Ảnh bằng Python. 

Vì sao dùng Qwen Image Edit với LoRA Multiple Angles?

Qwen-Image-Edit-2509 là phiên bản mới nhất của mô hình chỉnh sửa ảnh Qwen với độ nhất quán cao hơn và hỗ trợ chỉnh sửa nhiều ảnh. LoRA Multiple-Angles bổ sung điều khiển “máy ảnh ảo” đáng tin cậy để bạn có thể nói:

• 将镜头转为广角镜头 (chuyển sang góc rộng)
• 将镜头转为特写镜头 (chuyển sang cận cảnh)
• 将镜头向左旋转45度 (xoay trái 45°)
• 将镜头转为俯视 (góc nhìn từ trên xuống)

Những lệnh này luôn tái khung cùng một sản phẩm mà không bịa ra sản phẩm mới.

Hướng dẫn từng bước Qwen Image Edit: Xây trình tăng lực ảnh sản phẩm 

Trong hướng dẫn này, chúng ta sẽ xây dựng một ứng dụng chuyển đổi một ảnh sản phẩm thành bộ góc chụp chuẩn studio (gồm các góc như rộng, cận, 45° trái/phải và từ trên xuống), kèm preset lifestyle tùy chọn và chế độ xem trước nhanh. Ứng dụng dùng mô hình Qwen/Qwen-Image-Edit-2509 và LoRA Multiple-Angles trong UI Gradio.

Chúng ta sẽ đi từ thiết lập môi trường đến tải mô hình, hàm hỗ trợ sinh ảnh và web UI.

Bước 1: Điều kiện tiên quyết

Trước tiên, cài tất cả phụ thuộc runtime. Chúng ta dùng PyTorch với bánh xe CUDA, công cụ Hugging Face, thư viện Diffusers, Gradio cho UI và Pillow/OpenCV để xử lý ảnh.

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/diffusersĐược hỗ trợ bởi

Ý nghĩa của từng thành phần:

• CUDA Wheels: Dòng PyTorch trỏ tới bánh xe NVIDIA CUDA 12.1 để tăng tốc GPU.
• Transformers và Diffusers: Transformers quản lý cấu hình và tokenizer trong khi Diffusers cung cấp QwenImageEditPlusPipeline.
• Safetensors: Định dạng tensor an toàn (nhanh và an toàn hơn Pickle).
• OpenCV-headless và Pillow: I/O ảnh mạnh mẽ và thay đổi kích thước cho tiền/xử lý hậu kỳ.
• Gradio: UI web nhanh, chạy cục bộ và trên Colab.

Khi môi trường đã sẵn sàng, chúng ta có thể xác thực với Hugging Face (tùy chọn) và tải mô hình.

Bước 2: Xác thực Hugging Face

Một số mô hình hoặc adapter có thể yêu cầu xác thực từ HuggingFace. Bước này đăng nhập một lần cho phiên làm việc.

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")Được hỗ trợ bởi

Bắt đầu bằng cách đăng nhập tài khoản HuggingFace của bạn và tìm Access Tokens trong cài đặt tài khoản. Nhấp Create new token và tạo token mới với loại Read. Chọn quyền cần thiết và tạo token.

Trong môi trường production/Colab, không hardcode token; hãy dùng biến môi trường hoặc “Secrets” của Colab.

Bước 3: Tải mô hình và thiết lập pipeline

Phần này chúng ta thiết lập pipeline Qwen-Image-Edit, tải LoRA góc và thêm công tắc Nhanh với cấu hình nhận biết GPU. Lưu ý đoạn mã chạy hiệu quả trên GPU A100 RAM lớn.

Bước 3.1:  Import và cấu hình GPU

Giờ chúng ta import thư viện lõi và phát hiện GPU để tự động đặt độ chính xác, attention slicing và VAE slicing cho ổn định.

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),
}Được hỗ trợ bởi

Các thành phần chính của đoạn mã trên:

• Tự động cấu hình GPU (hàm get_gpu_config): Chúng ta phát hiện bộ tăng tốc sẵn có và trả về một dictionary cấu hình nhỏ dùng để chọn thiết bị (cpu/cuda), dtype (như bfloat16 trên GPU) và hành vi bộ nhớ:
• Trên CPU, mặc định float32 và bật attention/VAE slicing để an toàn.
• Với T4 / <20 GB VRAM, dùng bfloat16 nhưng bật slicing để tránh OOM.
• Với GPU ≥ 20 GB (như A100), tắt slicing và cho phép batch lớn hơn để tăng tốc.
• ID mô hình và adapter: Chúng ta tải Qwen-Image-Edit-2509 làm trình chỉnh sửa lõi, kèm LoRA Multiple-angles để điều khiển máy ảnh, và tùy chọn pha trộn LoRA Lightning khi bật Chế độ Nhanh.  
• HF_BASE_MODEL = "Qwen/Qwen-Image-Edit-2509" là xương sống chỉnh sửa ảnh chính.
• LORA_ANGLES = "dx8152/Qwen-Edit-2509-Multiple-angles" thêm điều khiển “máy ảnh ảo”.
• LORA_LIGHTNING = "lightx2v/Qwen-Image-Lightning" là adapter tăng tốc tùy chọn cho xem trước nhanh.

Lưu ý: với Chế độ HQ, chỉ giữ adapter góc hoạt động.

• Angle macros: ANGLE_MACROS ánh xạ nhãn như “Wide-angle” hay “Top-down” sang lệnh tiếng Trung tương đương mà LoRA góc hiểu ổn định. Các lệnh này liên tục di chuyển máy ảnh ảo (di chuyển/xoay/zoom) mà không đổi danh tính.
• Preset nền: BACKGROUND_PRESETS là các đoạn tiếng Anh ngắn như “marble surface”, “soft gray studio”, được ghép vào prompt cuối. Chúng độc lập với macro góc và chịu trách nhiệm điều khiển bối cảnh.
• Tỷ lệ khung (ASPECT_RATIOS): Cho phép tạo canvas (1:1, 4:3, 16:9, v.v.) và thay đổi kích thước hoặc crop giữa cho ảnh đầu vào trước suy luận để đầu ra không cần crop hậu kỳ.

Chúng ta đã thiết lập GPU và adapter. Hãy khởi tạo pipeline Diffusers và gắn các LoRA tiếp theo.

Bước 3.2: Pipeline

Tiếp theo, tải pipeline Qwen Edit nền tảng, bật tối ưu bộ nhớ theo GPU, và xếp LoRA Multiple-Angles. Chúng ta cũng triển khai công tắc chế độ để tùy chọn thêm LoRA Lightning cho xem trước nhanh.

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)Được hỗ trợ bởi

Đoạn mã trên là lớp thiết lập pipeline cho ứng dụng Product Shot Booster, thực hiện các chức năng sau:

• Khởi tạo pipeline: Khởi tạo QwenImageEditPlusPipeline từ mô hình nền tảng (Qwen/Qwen-Image-Edit-2509), chuyển sang thiết bị được phát hiện (CPU/GPU) và đặt độ chính xác tensor (torch_dtype) theo phần cứng của bạn.
• An toàn bộ nhớ: Trên GPU nhỏ, bật attention và VAE slicing để giảm đỉnh VRAM và tránh lỗi thiếu bộ nhớ, đánh đổi một chút tốc độ để ổn định.
• Phối ghép LoRA: Tải LoRA Multiple-angles để có điều khiển “máy ảnh ảo” lặp lại (di chuyển/xoay/zoom) và tùy chọn pha trộn LoRA Lightning để xem trước nhanh hơn.
• Logic chuyển chế độ: Hàm trợ giúp set_pipeline_mode() và cờ current_mode quản lý trạng thái HQ vs Nhanh, tránh tải lại Lightning thừa và cho phép bạn chuyển adapter.

Pipeline đã sẵn sàng. Tiếp theo chúng ta sẽ kết nối các hàm sinh ảnh và UI Gradio.

Bước 4: Các hàm sinh ảnh

Các hàm sinh ảnh sẽ dựng prompt, đổi kích thước theo tỷ lệ khung mục tiêu, chạy pipeline qua các góc được chọn và đóng gói kết quả để tải về dưới dạng tệp zip.

Bước 4.1: Trình ghép Prompt và Trợ giúp đổi kích thước ảnh

Trước khi gọi mô hình, chúng ta chuẩn hóa đầu vào bằng hai hàm trợ giúp không trạng thái:

• compose_prompt(): Lắp ghép một chuỗi hướng dẫn từ góc máy, preset nền, cảnh tùy chỉnh và ghi chú phong cách. Mệnh đề ngắn gọn giúp parsing hướng dẫn của Qwen ổn định và tránh quá nhấn mạnh phần nào.
• resize_image(): Khớp ảnh nguồn với tỷ lệ khung mục tiêu bằng chiến lược scale-to-cover, dùng nội suy Lanczos để giảm/tăng kích thước chất lượng cao và crop giữa để chủ thể chính luôn trong khung.

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 imgĐược hỗ trợ bởi

Hai hàm trên thực hiện:

• Prompt có thể ghép: Nối các phần bằng " | " để các mệnh đề tách bạch, trong khi Qwen-Edit xử lý dấu câu và phân tích ổn định, không thiên vị mệnh đề cuối. Dùng .strip() với văn bản người dùng để tránh đoạn rỗng.
• Toán học scale-to-cover: Đảm bảo ảnh đã đổi kích thước bao phủ hoàn toàn canvas mục tiêu theo cả hai chiều.
• Nội suy Lanczos: Bộ lọc chất lượng cao, giữ chi tiết khi giảm kích thước và giảm răng cưa khi phóng to.
• Crop giữa: Sau khi đổi kích thước, crop đúng canvas mục tiêu từ tâm để giữ bố cục điển hình và tránh cắt lệch bất ngờ.

Khi đã có các trợ giúp, chúng ta có thể chạy vòng lặp sinh đa góc và đóng gói kết quả.

Bước 4.2: Sinh ảnh 

Tiếp theo, chúng ta kiểm tra đầu vào, chuẩn hóa ảnh theo tỷ lệ khung đã chọn, lặp qua các góc đã chọn và chạy pipeline trong inference_mode. Cuối cùng, trả về tệp zip chứa tất cả ảnh đã tạo.

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_pathĐược hỗ trợ bởi

generate_images() triển khai sinh đa góc và xuất bằng cách:

• Xác thực, chuẩn hóa và cấu hình: Kiểm tra đã tải ảnh và chọn góc, sau đó khớp ảnh với tỷ lệ đã chọn (đổi kích thước và crop giữa) và chuyển HQ vs Nhanh qua set_pipeline_mode(use_lightning). 
• Suy luận hiệu quả: Với mỗi góc, dựng một chuỗi hướng dẫn gồm macro góc, preset nền, cảnh và phong cách. Chuẩn bị đầu vào cho Diffusers và chạy trong torch.inference_mode() để tiết kiệm bộ nhớ. Trên GPU VRAM thấp (như T4), gọi torch.cuda.empty_cache() mỗi góc giúp giảm phân mảnh.
• Gộp kết quả kèm phản hồi UI: Cập nhật tiến độ Gradio khi mỗi góc hoàn tất và gom tất cả đầu ra vào một danh sách để zip ở bước sau.

create_zip(images) cung cấp xuất bản di động, ghi một tệp zip với manifest.txt ngắn gọn cùng ảnh được mã hóa qua bộ đệm trong bộ nhớ (BytesIO) cho tệp không mất dữ liệu và trả về None nếu không có ảnh.

Với khâu sinh và đóng gói hoàn tất, UI có thể kích hoạt một lượt sinh đa góc và cung cấp tải xuống trọn bộ góc chỉ với một cú nhấp.

Bước 5: UI Gradio

UI này cho phép người dùng tải ảnh sản phẩm, chọn góc và tỷ lệ khung, chọn preset nền, đặt ghi chú phong cách và sinh ảnh đa góc ngay lập tức. 

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)Được hỗ trợ bởi

Đoạn mã trên xây dựng ứng dụng Gradio tương tác, nối một hành động sinh ảnh với suy luận và cung cấp UI web có thể chia sẻ, bằng cách sử dụng:

• Đầu vào (cột trái): Khung trái thu thập mọi thứ mô hình cần bằng gr.Image để tải ảnh sản phẩm, gr.CheckboxGroup cho góc máy, hai gr.Dropdowns cho tỷ lệ khung và preset nền, và hai gr.Textbox cho cảnh tùy chỉnh và ghi chú phong cách để tinh chỉnh diện mạo.
• Đầu ra (cột phải): gr.Gallery hiển thị tất cả góc đã sinh trong dạng lưới để bạn so sánh bố cục nhanh chóng, và thành phần gr.File cung cấp tệp ZIP ảnh PNG để tải nhanh.
• Cài đặt nâng cao: gr.Checkbox bật Chế độ Nhanh (Lightning LoRA) để xem trước nhanh trên GPU dòng T4, trong khi Seed và Steps điều chỉnh khả năng tái lập và đánh đổi chất lượng/thời gian. Guidance và True-CFG điều hướng độ mạnh chỉnh sửa so với tính ổn định danh tính, và Images per Angle cho phép tạo nhiều biến thể cho mỗi macro góc trong một lượt.
• Kết nối giao diện (hành động): Một nút Generate duy nhất kết nối tất cả đầu vào tới hàm generate_images() (chạy Qwen Edit với adapter đã chọn) rồi tới create_zip() (đóng gói đầu ra), trả về cả gallery và ZIP cho giao diện.
• Khởi chạy ứng dụng: Cuối cùng, phương thức demo.launch() khởi chạy web app và cung cấp URL chia sẻ công khai—hoàn hảo cho phiên Colab, demo nhanh, hoặc gửi liên kết cho đối tác tự dùng thử.

Cuối cùng, nhấn Generate và xem trọn bộ góc được render. 

Dưới đây là kết quả từ các thử nghiệm của tôi với mô hình này. Trước tiên, bạn có thể thấy sản phẩm hiển thị thế nào dựa trên các tham số khác nhau.