Variații și iterații
Pe această pagină
Actualizat pe 2 noiembrie 2026 — Modele de imagini.
gpt-image-1, modelul pentru care a fost scris inițial acest curs, a fost întrerupt la 23 octombrie 2026. În plus,gpt-image-1.5,gpt-image-1-minișichatgpt-image-latestvor fi retrase la 1 decembrie 2026. Exemplele folosesc acumgpt-image-2.5-sunburst, care oferă cea mai mare precizie pentru editare;gpt-image-2.5-flareeste mai rapid pentru generarea standard. Ambele modele suportă, de asemenea, setările de calitatexhighșimax. Modelele GPT Image returnează întotdeauna imaginile în base64: parametrulresponse_formatde la modelele DALL·E mai vechi nu mai este acceptat și a fost eliminat din cod. Sursă: Image generation (OpenAI).
Variații și iterații
Obținerea imaginii perfecte din prima încercare este rară. Munca reală implică generarea de variații, compararea acestora și apoi rafinarea progresivă a promptului până când obțineți rezultatul dorit. Această lecție vă oferă cele trei instrumente pentru această metodă: variația prin re-executare, variația prin modificarea promptului și iterația prin rafinare succesivă.
Generarea de variații ale aceluiași concept
Cea mai simplă metodă este re-executarea generării cu același prompt: GPT Image produce un rezultat diferit de fiecare dată. Acest lucru este util la începutul explorării, când nu știți încă exact ce căutați și doriți să vedeți gama de interpretări posibile ale unei idei.
from openai import OpenAI
import base64
client = OpenAI()
def generate_variations(prompt: str, n_variations: int, prefix: str):
"""Generează mai multe variații independente ale aceluiași 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"Variația {i+1} salvată: {path}")
return paths
variations = generate_variations(
prompt="Ilustrație cu un robot grădinar udând flori, stil copilăresc și colorat",
n_variations=5,
prefix="gardener_robot"
)
Variații prin modificarea promptului
Abordarea anterioară vă lasă la voia întâmplării; aceasta vă oferă control. Fixați un subiect invariant — aici, o ceașcă de cafea aburindă pe o masă de lemn — și modificați o singură dimensiune: atmosfera. Cele cinci rezultate devin apoi comparabile, deoarece știți exact ce le diferențiază. Aceasta este diferența dintre cinci încercări și un experiment.
from openai import OpenAI
import base64
client = OpenAI()
base_prompt = "Ceașcă de cafea aburindă pe o masă de lemn"
moods = [
"lumină blândă de dimineață, tonuri calde",
"atmosferă de cafenea pariziană, alb-negru",
"stil pop art, culori saturate",
"minimalism scandinav, fundal alb",
"atmosferă cozy de iarnă, lumini bokeh",
]
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"Atmosferă: {mood[:30]}... → {path}")
Iterație prin rafinarea promptului
Când rezultatul nu este satisfăcător, reacția corectă nu este să re-executați sperând la noroc mai bun, ci să adăugați constrângerea lipsă. Seria de mai jos arată această progresie într-un exemplu concret: „Un logo pentru un startup fintech“ nu spune nimic modelului; a doua iterație limitează numărul de culori și fundalul; a treia numește metafora vizuală și paleta; a patra coboară până la codurile hexazecimale și grosimea liniei. Cu fiecare trecere, spațiul rezultatelor posibile se îngustează, iar reproductibilitatea crește.
from openai import OpenAI
import base64
client = OpenAI()
iterations = [
# Iterația 1: prompt de bază
"Un logo pentru un startup fintech",
# Iterația 2: adăugarea constrângerilor vizuale
"Un logo pentru un startup fintech, design minimalist, maximum două culori, fundal transparent",
# Iterația 3: precizarea stilului
(
"Logo minimalist pentru un startup fintech, iconiță geometrică abstractă "
"evocând creșterea, paletă albastru marin și verde smarald, fără text, stil vectorial"
),
# Iterația 4: ajustări fine
(
"Logo minimalist pentru un startup fintech, iconiță geometrică abstractă: "
"două săgeți împletite formând un romb, albastru marin (#1B2A4A) și "
"verde smarald (#2ECC71), contur subțire de 2px, fundal alb, randare vectorială ascuțită, centrat"
),
]
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"Iterația {i+1}: {prompt[:60]}...")
print(f" → {path}\n")
Pipeline de iterație automatizat
Într-un proiect puțin mai lung, memoria umană nu este suficientă: după cincisprezece imagini, nu mai știți care prompt a produs care rezultat. Pipeline-ul următor structurează munca în runde, generează mai multe variante per rundă, denumește fișierele astfel încât să fie trasabile și păstrează istoricul complet al prompturilor într-un fișier JSON. Acest fișier de istoric este ceea ce face configurarea valoroasă: vă permite să reveniți și să capitalizați de la un proiect la altul.
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 de iterație: generează mai multe variante per rundă,
păstrează un istoric al prompturilor și rezultatelor.
"""
history = []
current_prompt = brief
for round_num in range(1, n_rounds + 1):
print(f"\n{'='*50}")
print(f"RUNDA {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" Varianta {i+1}: {path}")
history.append({
"round": round_num,
"prompt": current_prompt,
"images": round_images
})
# Rafinarea promptului pentru runda următoare
if round_num < n_rounds:
current_prompt += ", mai multe detalii, compoziție mai bună"
# Salvarea istoricului
with open("pipeline_history.json", "w") as f:
json.dump(history, f, indent=2, ensure_ascii=False)
print(f"\nIstoric salvat: pipeline_history.json")
return history
iteration_pipeline(
brief="Ilustrație cu o librărie independentă văzută din exterior, seară de toamnă, stil Ghibli",
n_rounds=3,
n_per_round=3
)
Compararea variațiilor într-un catalog
Deschiderea a nouă fișiere PNG unul câte unul într-un vizualizator nu permite nicio comparație serioasă. În schimb, generați o pagină HTML care le afișează alături, cu imaginile codificate în base64, astfel încât fișierul să fie autonom și partajabil ca atare cu un client sau un director artistic.
import base64
from pathlib import Path
from glob import glob
def generate_catalog(images: list[str], title: str, output: str = "catalog.html"):
"""Creează o pagină HTML cu toate imaginile alăturate."""
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"Catalog generat: {output}")
images = sorted(glob("pipeline_r*_v*.png"))
generate_catalog(images, "Variații — Librărie Ghibli")
Disciplina iterației
Câteva principii separă iterația productivă de încercarea și eroarea costisitoare. Modificați un singur parametru pe rând, altfel nu veți ști niciodată care dintre ele a îmbunătățit rezultatul. Păstrați un istoric al prompturilor și al randărilor, așa cum face pipeline-ul de mai sus, pentru a capitaliza în loc să o luați de la zero la fiecare proiect. Lucrați cu quality: low pe întreaga durată a fazei de explorare și treceți la high doar pentru randarea finală, altfel veți plăti scump pentru imagini pe care le veți arunca. Când căutați pur și simplu diversitate rapidă, preferați un singur apel cu parametrul n în locul unei bucle de cereri. În final, denumiți fișierele descriptiv: este un detaliu trivial în prima zi, decisiv după două sute de imagini.
Aplicați acum această secvență completă unui subiect la alegerea dumneavoastră — logo, ilustrație sau fotografie de produs. Generați trei variante cu un prompt inițial, rafinați acel prompt în lumina rezultatelor, generați trei noi variante, apoi produceți catalogul HTML comparativ al celor șase imagini.