Variazioni e iterazioni
In questa pagina
Aggiornato il 2 novembre 2026 — Modelli immagine.
gpt-image-1, il modello per cui questo corso era stato originariamente scritto, è stato dismesso il 23 ottobre 2026. Inoltre,gpt-image-1.5,gpt-image-1-miniechatgpt-image-latestverranno ritirati il 1° dicembre 2026. Gli esempi ora utilizzanogpt-image-2.5-sunburst, che offre la massima precisione per l’editing;gpt-image-2.5-flareè più veloce per la generazione standard. Entrambi i modelli supportano anche le impostazioni di qualitàxhighemax. I modelli GPT Image restituiscono sempre le immagini in base64: il parametroresponse_formatdei vecchi modelli DALL·E non è più accettato ed è stato rimosso dal codice. Fonte: Image generation (OpenAI).
Variazioni e iterazioni
Ottenere l’immagine perfetta al primo tentativo è raro. Il lavoro reale consiste nel generare variazioni, confrontarle e affinare progressivamente il prompt fino a raggiungere il risultato desiderato. Questa lezione ti fornisce i tre strumenti per questo metodo: variazione tramite riesecuzione, variazione tramite modifica del prompt e iterazione attraverso un affinamento successivo.
Generare variazioni dello stesso concetto
Il metodo più semplice è rieseguire la generazione con lo stesso prompt: GPT Image produce un risultato diverso ogni volta. Questo è utile all’inizio dell’esplorazione, quando non sai ancora cosa cerchi e vuoi vedere la gamma di possibili interpretazioni di un’idea.
from openai import OpenAI
import base64
client = OpenAI()
def generate_variations(prompt: str, n_variations: int, prefix: str):
"""Genera diverse variazioni indipendenti dello stesso prompt."""
paths = []
for i in range(n_variations):
response = client.images.generate(
model="gpt-image-2.5-sunburst",
prompt=prompt,
size="1024x1024",
quality="medium",
)
path = f"{prefix}_v{i+1}.png"
data = base64.b64decode(response.data[0].b64_json)
with open(path, "wb") as f:
f.write(data)
paths.append(path)
print(f"Variazione {i+1} salvata: {path}")
return paths
variations = generate_variations(
prompt="Illustrazione di un robot giardiniere che annaffia i fiori, stile infantile e colorato",
n_variations=5,
prefix="gardener_robot"
)
Variazioni modificando il prompt
L’approccio precedente ti lascia in balia della casualità; questo ti dà il controllo. Fissi un soggetto invariante — qui, una tazza di caffè fumante su un tavolo di legno — e muovi solo una dimensione: l’atmosfera. I cinque risultati diventano quindi confrontabili, poiché sai esattamente cosa li distingue. Questa è la differenza tra cinque tentativi e un esperimento.
from openai import OpenAI
import base64
client = OpenAI()
base_prompt = "Tazza di caffè fumante su un tavolo di legno"
moods = [
"luce morbida del mattino, toni caldi",
"atmosfera da caffè parigino, bianco e nero",
"stile pop art, colori saturi",
"minimalista scandinavo, sfondo bianco",
"atmosfera invernale accogliente, luci bokeh a filo",
]
for i, mood in enumerate(moods):
prompt = f"{base_prompt}, {mood}"
response = client.images.generate(
model="gpt-image-2.5-sunburst",
prompt=prompt,
size="1024x1024",
quality="medium",
)
path = f"cafe_mood_{i+1}.png"
data = base64.b64decode(response.data[0].b64_json)
with open(path, "wb") as f:
f.write(data)
print(f"Atmosfera: {mood[:30]}... → {path}")
Iterazione affinando il prompt
Quando il risultato non è soddisfacente, la reazione giusta non è rieseguire sperando in una sorte migliore, ma aggiungere il vincolo mancante. La serie seguente mostra questa progressione in un esempio pratico: “Un logo per una startup fintech” non dice nulla al modello; la seconda iterazione delimita il numero di colori e lo sfondo; la terza nomina la metafora visiva e la palette; la quarta scende fino ai codici esadecimali e allo spessore del tratto. A ogni passaggio, lo spazio dei possibili risultati si restringe e la riproducibilità aumenta.
from openai import OpenAI
import base64
client = OpenAI()
iterations = [
# Iterazione 1: prompt base
"Un logo per una startup fintech",
# Iterazione 2: aggiunta di vincoli visivi
"Un logo per una startup fintech, design minimalista, massimo due colori, sfondo trasparente",
# Iterazione 3: precisione dello stile
(
"Logo minimalista per una startup fintech, icona geometrica astratta "
"che evoca la crescita, palette blu navy e verde smeraldo, senza testo, stile vettoriale"
),
# Iterazione 4: aggiustamenti fini
(
"Logo minimalista per una startup fintech, icona geometrica astratta: "
"due frecce intrecciate che formano un diamante, blu navy (#1B2A4A) e "
"verde smeraldo (#2ECC71), tratto sottile da 2px, sfondo bianco, rendering vettoriale nitido, centrato"
),
]
for i, prompt in enumerate(iterations):
response = client.images.generate(
model="gpt-image-2.5-sunburst",
prompt=prompt,
size="1024x1024",
quality="high",
)
path = f"logo_iteration_{i+1}.png"
data = base64.b64decode(response.data[0].b64_json)
with open(path, "wb") as f:
f.write(data)
print(f"Iterazione {i+1}: {prompt[:60]}...")
print(f" → {path}\n")
Pipeline di iterazione automatizzata
In un progetto leggermente più lungo, la memoria umana non basta: dopo quindici immagini, non sai più quale prompt ha prodotto quale risultato. La pipeline seguente struttura il lavoro in round, genera diverse varianti per round, nomina i file in modo tracciabile e mantiene lo storico completo dei prompt in un file JSON. Questo file di storico è ciò che rende preziosa l’impostazione: ti permette di tornare indietro e capitalizzare da un progetto all’altro.
from openai import OpenAI
import base64
import json
client = OpenAI()
def iteration_pipeline(brief: str, n_rounds: int = 3, n_per_round: int = 3):
"""
Pipeline di iterazione: genera diverse varianti per round,
mantiene uno storico di prompt e risultati.
"""
history = []
current_prompt = brief
for round_num in range(1, n_rounds + 1):
print(f"\n{'='*50}")
print(f"ROUND {round_num} — Prompt: {current_prompt[:80]}...")
print(f"{'='*50}")
round_images = []
for i in range(n_per_round):
response = client.images.generate(
model="gpt-image-2.5-sunburst",
prompt=current_prompt,
size="1024x1024",
quality="medium",
)
path = f"pipeline_r{round_num}_v{i+1}.png"
data = base64.b64decode(response.data[0].b64_json)
with open(path, "wb") as f:
f.write(data)
round_images.append(path)
print(f" Variante {i+1}: {path}")
history.append({
"round": round_num,
"prompt": current_prompt,
"images": round_images
})
# Affina il prompt per il round successivo
if round_num < n_rounds:
current_prompt += ", più dettagli, migliore composizione"
# Salva lo storico
with open("pipeline_history.json", "w") as f:
json.dump(history, f, indent=2, ensure_ascii=False)
print(f"\nStorico salvato: pipeline_history.json")
return history
iteration_pipeline(
brief="Illustrazione di una libreria indipendente vista dall'esterno, sera d'autunno, stile Ghibli",
n_rounds=3,
n_per_round=3
)
Confrontare le variazioni in un catalogo
Aprire nove PNG uno per uno in un visualizzatore non permette alcun confronto serio. Invece, genera una pagina HTML che li mostri fianco a fianco, con le immagini codificate in base64 in modo che il file sia autonomo e condivisibile così com’è con un cliente o un direttore artistico.
import base64
from pathlib import Path
from glob import glob
def generate_catalog(images: list[str], title: str, output: str = "catalog.html"):
"""Crea una pagina HTML con tutte le immagini fianco a fianco."""
html_parts = [
'<!DOCTYPE html><html><head><meta charset="utf-8">',
f'<title>{title}</title>',
'<style>',
'body { background: #111; color: #fff; font-family: sans-serif; padding: 2rem; }',
'.grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(300px, 1fr)); gap: 1rem; }',
'.card { background: #222; border-radius: 8px; overflow: hidden; }',
'.card img { width: 100%; display: block; }',
'.card p { padding: 0.5rem 1rem; font-size: 0.85rem; color: #aaa; }',
'</style></head><body>',
f'<h1>{title}</h1><div class="grid">',
]
for img_path in images:
with open(img_path, "rb") as f:
b64 = base64.b64encode(f.read()).decode()
html_parts.append(f'<div class="card">')
html_parts.append(f'<img src="data:image/png;base64,{b64}" />')
html_parts.append(f'<p>{Path(img_path).name}</p></div>')
html_parts.append('</div></body></html>')
with open(output, "w") as f:
f.write("\n".join(html_parts))
print(f"Catalogo generato: {output}")
images = sorted(glob("pipeline_r*_v*.png"))
generate_catalog(images, "Variazioni — Libreria Ghibli")
La disciplina dell’iterazione
Alcuni principi separano l’iterazione produttiva dal costoso tentativo ed errore. Cambia solo un parametro alla volta, altrimenti non saprai mai quale ha migliorato il risultato. Mantieni uno storico dei tuoi prompt e rendering, come fa la pipeline sopra, per capitalizzare invece di ricominciare da zero a ogni progetto. Lavora con quality: low durante l’intera fase di esplorazione e passa a high solo per il rendering finale, altrimenti pagherai a peso d’oro immagini che butterai via. Quando cerchi semplicemente una rapida diversità, preferisci una singola chiamata con il parametro n rispetto a un loop di richieste. Infine, nomina i tuoi file in modo descrittivo: è un dettaglio banale il primo giorno, decisivo dopo duecento immagini.
Ora applica questa sequenza completa a un soggetto a tua scelta — logo, illustrazione o foto di prodotto. Genera tre varianti con un prompt iniziale, affina quel prompt alla luce dei risultati, genera tre nuove varianti, quindi produci il catalogo HTML comparativo delle sei immagini.