Tutorial Qwen-Image-Edit-2509: genera angolazioni prodotto pronte da studio

I venditori singoli e i piccoli brand raramente hanno il budget per un intero servizio fotografico di prodotto. In questa guida, costruiremo ed eseguiremo un'app Gradio che trasforma un'unica immagine di input in render di prodotto multi-angolazione pronti per l'e-commerce (grandangolo, macro, ±45°, vista dall'alto) usando Qwen-Image-Edit-2509 con controlli di fotocamera virtuale basati su LoRA per una fotografia di prodotto AI riproducibile.

Dietro le quinte, usiamo:

• Modello base: Qwen/Qwen-Image-Edit-2509 (Apache-2.0)
• LoRA di controllo angolazioni: dx8152/Qwen-Edit-2509-Multiple-angles
• LoRA di velocità opzionale: lightx2v/Qwen-Image-Lightning

In questo tutorial imparerai a:

• Caricare la pipeline di editing Qwen e impilare più LoRA.
• Controllare i movimenti di camera con macro di angolazione robuste.
• Costruire una UI Gradio pulita per creator e team e‑commerce.
• Esportare tutti i risultati in uno ZIP per un passaggio di consegne agevole.

Se ti interessa capire meglio come vengono processati i dati immagine nel deep learning, dai un'occhiata al percorso di competenze Image Processing in Python. 

Perché usare Qwen Image Edit con Multiple Angles LoRA?

Qwen-Image-Edit-2509 è l'ultima iterazione del modello di editing immagine di Qwen con coerenza migliorata ed editing multi-immagine. Il Multiple-Angles LoRA introduce affidabili controlli da “telecamera virtuale”, così puoi dire:

• 将镜头转为广角镜头 (passa a grandangolo)
• 将镜头转为特写镜头 (passa a primo piano)
• 将镜头向左旋转45度 (ruota di 45° a sinistra)
• 将镜头转为俯视 (vista dall'alto)

Questi comandi ricomprendono in modo coerente lo stesso prodotto senza inventarne uno nuovo.

Tutorial passo dopo passo su Qwen Image Edit: costruire un booster per scatti prodotto 

In questa guida costruiremo un'app che trasforma un'unica immagine di prodotto in un set di angolazioni pronte da studio (inclusi grandangolo, close-up, 45° sinistra/destra e vista dall'alto), con preset lifestyle opzionali e modalità anteprima veloce. Usa il modello Qwen/Qwen-Image-Edit-2509 e un LoRA Multiple-Angles incapsulato in una UI Gradio.

Partiremo dal setup dell'ambiente per arrivare al caricamento del modello, helper per la generazione e una web UI.

Passo 1: Prerequisiti

Per prima cosa, installa tutte le dipendenze runtime. Usiamo PyTorch con wheel CUDA, tool Hugging Face, libreria Diffusers, Gradio per la UI e Pillow/OpenCV per la gestione delle immagini.

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/diffusersOfferto da

Ecco a cosa serve ciascun prerequisito:

• Wheel CUDA: la riga di PyTorch punta alle wheel NVIDIA CUDA 12.1 per l'accelerazione GPU.
• Transformers e Diffusers: Transformers gestisce configurazioni e tokenizer, mentre Diffusers fornisce la QwenImageEditPlusPipeline.
• Safetensors: fornisce un formato tensor sicuro (più veloce e sicuro di Pickle).
• OpenCV-headless e Pillow: offrono I/O immagine robusto e ridimensionamento per pre/post-processing.
• Gradio: è una web UI rapida che funziona in locale e in Colab.

Con l'ambiente pronto, possiamo autenticarci su Hugging Face (opzionale) e caricare i modelli.

Passo 2: autenticazione Hugging Face

Alcuni modelli o adapter possono richiedere l'autenticazione da HuggingFace. Questo passaggio effettua il login una volta per la sessione.

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")Offerto da

Inizia effettuando l'accesso al tuo account HuggingFace e cercando gli Access Token nelle impostazioni dell'account. Clicca su Create new token e genera un nuovo token con tipo Read. Seleziona i permessi necessari e genera un nuovo token.

In produzione/Colab, non inserire i token nel codice: usa invece variabili d'ambiente o le “Secrets” di Colab.

Passo 3: carica il modello e configura la pipeline

In questa sezione configuriamo la pipeline Qwen-Image-Edit, carichiamo la LoRA delle angolazioni e aggiungiamo un toggle Fast con impostazioni consapevoli della GPU. Nota che questo codice gira in modo efficiente su una GPU A100 con molta RAM.

Passo 3.1:  Import e configurazione GPU

Ora importeremo le librerie core e rileveremo la GPU per impostare automaticamente precisione, attention slicing e VAE slicing per la stabilità.

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),
}Offerto da

Ecco i componenti chiave dei blocchi di codice qui sopra:

• Configurazione GPU automatica (funzione get_gpu_config): rileviamo l'acceleratore disponibile e restituiamo un piccolo dizionario di configurazione usato per scegliere device (cpu/cuda), dtype (come bfloat16 su GPU) e comportamenti di memoria:
• Su CPU, impostiamo di default float32 e abilitiamo attention/VAE slicing per sicurezza.
• Su T4 / <20 GB di VRAM, teniamo bfloat16 ma abilitiamo lo slicing per evitare OOM.
• Su GPU da 20 GB+ (come A100), disabilitiamo lo slicing e consentiamo batch più grandi per la velocità.
• ID modello e adapter: carichiamo Qwen-Image-Edit-2509 come editor principale, insieme alla LoRA Multiple-angles per il controllo della camera e, facoltativamente, fondiamo la LoRA Lightning quando attivi la Modalità Veloce.  
• HF_BASE_MODEL = "Qwen/Qwen-Image-Edit-2509" è la spina dorsale principale di editing immagine.
• LORA_ANGLES = "dx8152/Qwen-Edit-2509-Multiple-angles" aggiunge controlli da “telecamera virtuale”.
• LORA_LIGHTNING = "lightx2v/Qwen-Image-Lightning" è un adapter di velocità opzionale per anteprime rapide.

Nota: per la Modalità HQ resta attivo solo l'adapter delle angolazioni.

• Macro di angolazione: ANGLE_MACROS mappa etichette come “Wide-angle” o “Top-down” a comandi equivalenti in cinese che la LoRA delle angolazioni interpreta in modo affidabile. Questi comandi muovono costantemente la telecamera virtuale (muovi/ruota/zoom) senza cambiare l'identità.
• Preset di sfondo: BACKGROUND_PRESETS sono brevi frammenti in inglese come “marble surface”, “soft gray studio”, che uniamo al prompt finale. Sono ortogonali alle macro di angolazione e si occupano di controllare la scena.
• Proporzioni (ASPECT_RATIOS): permettono di generare canvas (1:1, 4:3, 16:9, ecc.) e ridimensionare o ritagliare al centro l'input prima dell'inferenza, così da non dover ritagliare dopo la generazione.

Ora abbiamo GPU e adapter configurati. Istanziamo la pipeline Diffusers e colleghiamo le LoRA.

Passo 3.2: Pipeline

Successivamente, carichiamo la pipeline base Qwen Edit, abilitiamo le ottimizzazioni di memoria in base alla GPU e impiliamo la LoRA Multiple-Angles. Implementiamo anche un interruttore di modalità per aggiungere opzionalmente la LoRA Lightning per anteprime rapide.

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)Offerto da

Il codice sopra è lo strato di setup della pipeline per l'app Product Shot Booster e svolge le seguenti funzioni:

• Inizializzazione della pipeline: istanzia la QwenImageEditPlusPipeline dal modello base (Qwen/Qwen-Image-Edit-2509), la sposta sul device rilevato (CPU/GPU) e imposta la precisione tensoriale (torch_dtype) in base all'hardware.
• Sicurezza della memoria: su GPU più piccole abilita attention e VAE slicing per ridurre il picco di VRAM ed evitare errori di memoria, scambiando un po' di velocità per stabilità.
• Composizione LoRA: carica la LoRA Multiple-angles per fornire controlli “telecamera virtuale” ripetibili (muovi/ruota/zoom) e, opzionalmente, fonde la LoRA Lightning per anteprime più veloci.
• Logica di cambio modalità: l'helper set_pipeline_mode() e un flag current_mode gestiscono gli stati HQ vs Fast, prevenendo ricariche ridondanti di Lightning e permettendo di alternare gli adapter.

Ora la pipeline è pronta. Passiamo a collegare le funzioni di generazione e la UI Gradio.

Passo 4: funzioni di generazione

Le funzioni di generazione alimentano il processo costruendo i prompt, ridimensionando al rapporto d'aspetto target, eseguendo la pipeline sulle angolazioni selezionate e impacchettando i risultati in uno zip scaricabile.

Passo 4.1: Compositore di prompt e helper di ridimensionamento immagine

Prima di invocare il modello, normalizziamo gli input con due helper stateless:

• compose_prompt() function: questa funzione assembla una singola stringa di istruzioni da angolazione della camera, preset di sfondo, scena personalizzata e note di stile. Clausole concise aiutano a mantenere stabile il parsing delle istruzioni di Qwen ed evitano di sovrappesare una parte rispetto alle altre.
• resize_image() function: adatta l'immagine sorgente al rapporto d'aspetto target usando una strategia di scale-to-cover; il ricampionamento Lanczos aiuta nel down/up-scaling di alta qualità e un ritaglio centrale mantiene il soggetto principale in inquadratura.

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 imgOfferto da

Le due funzioni sopra svolgono i seguenti compiti:

• Prompt componibile: uniamo le parti con " | " per mantenere le clausole visivamente distinte, mentre Qwen-Edit gestisce la punteggiatura e produce un parsing coerente senza favorire l'ultima clausola. Usiamo anche .strip() con il testo dell'utente per evitare frammenti vuoti.
• Matematica scale-to-cover: garantisce che l'immagine ridimensionata copra completamente il canvas target in entrambe le dimensioni.
• Ricampionamento Lanczos: è un filtro di alta qualità che preserva i dettagli nel downsampling e riduce l'aliasing nell'upscaling.
• Ritaglio centrale: dopo il ridimensionamento, ritagliamo esattamente il canvas target dal centro per preservare la composizione tipica ed evitare tagli decentrati indesiderati.

Con gli helper pronti, possiamo eseguire un loop di generazione multi-angolazione e impacchettare i risultati.

Passo 4.2: Genera immagini 

Poi, validiamo gli input, adattiamo l'immagine al rapporto scelto, cicliamo sulle angolazioni selezionate e avviamo la pipeline in inference_mode. Infine, restituiamo uno zip con tutte le immagini generate.

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_pathOfferto da

La funzione generate_images() implementa la generazione multi-angolazione e l'export così:

• Validazione, normalizzazione e configurazione: controlla che sia stata caricata un'immagine e selezionate delle angolazioni, quindi adatta l'immagine al rapporto scelto (ridimensionamento e ritaglio centrale) e alterna tra modalità HQ e Veloce tramite set_pipeline_mode(use_lightning). 
• Inferenza efficiente: per ogni angolazione, costruisce una singola stringa di istruzioni che include macro dell'angolo, preset di sfondo, scena e stile. Prepara quindi gli input per Diffusers ed esegue sotto torch.inference_mode() per risparmiare memoria. Su GPU con poca VRAM (come T4), chiamate come torch.cuda.empty_cache() per angolo aiutano a ridurre la frammentazione.
• Aggrega i risultati con feedback UI: aggiorna il progresso in Gradio al completamento di ogni angolo e raccoglie tutte le uscite in un'unica lista per creare lo zip a valle.

La funzione create_zip(images) offre un export portatile: scrive uno zip con un breve manifest.txt insieme alla codifica delle immagini in memoria (BytesIO) per file lossless e restituisce None se non sono presenti immagini.

Con generazione e packaging definitivi, la UI può avviare un passaggio multi-angolazione e offrire il download con un clic del pacchetto completo di angoli.

Passo 5: UI Gradio

Questa UI consente di caricare un'immagine di prodotto, scegliere angolazioni e rapporti d'aspetto, selezionare un preset di sfondo, impostare note di stile e generare al volo immagini multi-angolazione. 

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)Offerto da

Il codice sopra costruisce un'app Gradio interattiva che collega un'unica azione di generazione all'inferenza ed espone una web UI condivisibile, usando:

• Input (colonna di sinistra): il pannello sinistro raccoglie tutto ciò che serve al modello usando un gr.Image per caricare la foto del prodotto, un gr.CheckboxGroup per le angolazioni di camera, due gr.Dropdown per rapporto d'aspetto e preset di sfondo e due campi gr.Textbox per scena personalizzata e note di stile per rifinire il look.
• Output (colonna di destra): un gr.Gallery mostra tutte le angolazioni generate in una griglia per confrontare le composizioni a colpo d'occhio, e un componente gr.File offre uno ZIP di PNG per un download rapido.
• Impostazioni avanzate: un gr.Checkbox attiva la Modalità Veloce (Lightning LoRA) per anteprime rapide su GPU di classe T4, mentre Seed e Steps regolano riproducibilità e trade-off qualità/tempo. Guidance e True-CFG bilanciano la forza dell'editing rispetto alla stabilità dell'identità e Images per Angle permette di produrre più varianti per macro di camera in un solo passaggio.
• Cablaggio dell'interfaccia (azione): un unico pulsante Generate collega tutti gli input alla funzione generate_images() (che esegue Qwen Edit con gli adapter selezionati) e poi alla funzione create_zip() (che impacchetta le uscite), restituendo sia la galleria sia lo ZIP all'interfaccia.
• Avvio app: infine, il metodo demo.launch() avvia la web app e fornisce un URL pubblico condivisibile — perfetto per sessioni Colab, demo rapide o per inviare ai stakeholder un link per provare lo strumento.

Infine, premi Generate e guarda il rendering del pacchetto completo di angolazioni. 

Ecco i risultati dei miei esperimenti con questo modello. Per prima cosa, puoi vedere come i prodotti vengono mostrati in base ai diversi parametri impostati.