Variationer och iterationer
På denna sida
Uppdaterat 2 november 2026 — Bildmodeller.
gpt-image-1, modellen som denna kurs ursprungligen skrevs för, lades ner den 23 oktober 2026. Dessutom kommergpt-image-1.5,gpt-image-1-miniochchatgpt-image-latestatt tas ur bruk den 1 december 2026. Exemplen använder nugpt-image-2.5-sunburst, som erbjuder högsta precision för redigering;gpt-image-2.5-flareär snabbare för standardgenerering. Båda modellerna stöder även kvalitetsinställningarnaxhighochmax. GPT Image-modeller returnerar alltid bilder i base64: parameternresponse_formatfrån äldre DALL·E-modeller accepteras inte längre och har tagits bort från koden. Källa: Image generation (OpenAI).
Variationer och iterationer
Att få den perfekta bilden vid första försöket är sällsynt. Verkligt arbete innebär att generera variationer, jämföra dem och sedan successivt vässa prompten tills du når önskat resultat. Denna lektion ger dig de tre verktygen för denna metod: variation genom omkörning, variation genom att modifiera prompten och iteration genom successiv förfining.
Generera variationer av samma koncept
Den enklaste metoden är att köra genereringen igen med samma prompt: GPT Image producerar ett annat resultat varje gång. Detta är användbart i början av utforskningen, när du ännu inte vet vad du letar efter och vill se spannet av möjliga tolkningar av en idé.
from openai import OpenAI
import base64
client = OpenAI()
def generate_variations(prompt: str, n_variations: int, prefix: str):
"""Generate several independent variations of the same 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"Variation {i+1} saved: {path}")
return paths
variations = generate_variations(
prompt="Illustration of a gardener robot watering flowers, childish and colorful style",
n_variations=5,
prefix="gardener_robot"
)
Variationer genom att modifiera prompten
Det tidigare tillvägagångssättet lämnar dig med slumpmässighet; detta ger dig kontroll. Du fixerar ett oföränderligt motiv – här en ångande kaffekopp på ett träbord – och rör bara en dimension: stämningen. De fem resultaten blir då jämförbara, eftersom du vet exakt vad som skiljer dem åt. Det är skillnaden mellan fem försök och ett experiment.
from openai import OpenAI
import base64
client = OpenAI()
base_prompt = "Steaming coffee cup on a wooden table"
moods = [
"soft morning light, warm tones",
"Parisian café vibe, black and white",
"pop art style, saturated colors",
"Scandinavian minimalist, white background",
"cozy winter atmosphere, bokeh string lights",
]
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"Mood: {mood[:30]}... → {path}")
Iteration genom att förfina prompten
När resultatet inte är tillfredsställande är inte rätt reaktion att köra om och hoppas på bättre tur, utan att lägga till den saknade begränsningen. Serien nedan visar denna progression i ett genomarbetat exempel: “En logotyp för ett fintech-startup” säger modellen ingenting; den andra iterationen begränsar antalet färger och bakgrunden; den tredje namnger den visuella metaforen och paletten; den fjärde går ner till hex-koder och linjetjocklek. Med varje genomgång smalnar utrymmet för möjliga resultat av och reproducerbarheten ökar.
from openai import OpenAI
import base64
client = OpenAI()
iterations = [
# Iteration 1: base prompt
"A logo for a fintech startup",
# Iteration 2: adding visual constraints
"A logo for a fintech startup, minimalist design, maximum two colors, transparent background",
# Iteration 3: style precision
(
"Minimalist logo for a fintech startup, abstract geometric icon "
"evoking growth, navy blue and emerald green palette, no text, vector style"
),
# Iteration 4: fine adjustments
(
"Minimalist logo for a fintech startup, abstract geometric icon: "
"two interlocking arrows forming a diamond, navy blue (#1B2A4A) and "
"emerald green (#2ECC71), 2px thin stroke, white background, sharp vector render, centered"
),
]
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"Iteration {i+1}: {prompt[:60]}...")
print(f" → {path}\n")
Automatiserad iterationspipeline
På ett något längre projekt räcker inte det mänskliga minnet: efter femton bilder vet du inte längre vilken prompt som producerade vilket resultat. Följande pipeline strukturerar arbetet i omgångar, genererar flera varianter per omgång, namnger filer så att de går att spåra och behåller hela historiken av prompter i en JSON-fil. Det är denna historikfil som gör upplägget värdefullt: den låter dig gå tillbaka och dra nytta av erfarenheter från ett projekt till nästa.
from openai import OpenAI
import base64
import json
client = OpenAI()
def iteration_pipeline(brief: str, n_rounds: int = 3, n_per_round: int = 3):
"""
Iteration pipeline: generates several variants per round,
keeps a history of prompts and results.
"""
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" Variant {i+1}: {path}")
history.append({
"round": round_num,
"prompt": current_prompt,
"images": round_images
})
# Refine the prompt for the next round
if round_num < n_rounds:
current_prompt += ", more details, better composition"
# Save the history
with open("pipeline_history.json", "w") as f:
json.dump(history, f, indent=2, ensure_ascii=False)
print(f"\nHistory saved: pipeline_history.json")
return history
iteration_pipeline(
brief="Illustration of an independent bookstore seen from outside, autumn evening, Ghibli style",
n_rounds=3,
n_per_round=3
)
Jämföra variationer i en katalog
Att öppna nio PNG-filer en efter en i en bildvisare möjliggör ingen seriös jämförelse. Generera istället en HTML-sida som visar dem sida vid sida, med bilder kodade i base64 så att filen är fristående och kan delas som den är med en kund eller art director.
import base64
from pathlib import Path
from glob import glob
def generate_catalog(images: list[str], title: str, output: str = "catalog.html"):
"""Create an HTML page with all images side by side."""
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 generated: {output}")
images = sorted(glob("pipeline_r*_v*.png"))
generate_catalog(images, "Variations — Ghibli Bookstore")
Iterationens disciplin
Några principer skiljer produktiv iteration från kostsamt trial-and-error. Ändra bara en parameter i taget, annars vet du aldrig vilken som förbättrade resultatet. Behåll en historik över dina prompter och renderingar, som pipelinen ovan gör, för att dra nytta av erfarenheter istället för att börja om från noll vid varje projekt. Arbeta med quality: low under hela utforskningsfasen och växla till high först för den slutgiltiga renderingen, annars betalar du dyrt för bilder du ändå slänger. När du bara söker snabb mångfald, föredra ett enda anrop med parametern n framför en loop av förfrågningar. Namnge slutligen dina filer beskrivande: det är en trivial detalj dag ett, men avgörande efter tvåhundra bilder.
Tillämpa nu hela denna sekvens på ett valfritt motiv – logotyp, illustration eller produktfoto. Generera tre varianter med en första prompt, förfina den prompten mot bakgrund av resultaten, generera tre nya varianter och producera sedan den jämförande HTML-katalogen över de sex bilderna.