Variationer og iterationer
På denne side
Opdateret 2. november 2026 — Billedmodeller.
gpt-image-1, modellen som dette kursus oprindeligt blev skrevet til, blev udfaset 23. oktober 2026. Derudover vilgpt-image-1.5,gpt-image-1-miniogchatgpt-image-latestblive trukket tilbage 1. december 2026. Eksemplerne bruger nugpt-image-2.5-sunburst, som tilbyder højeste præcision til redigering;gpt-image-2.5-flareer hurtigere til standardgenerering. Begge modeller understøtter også kvalitetsindstillingernexhighogmax. GPT Image-modeller returnerer altid billeder i base64: parameterenresponse_formatfra ældre DALL·E-modeller accepteres ikke længere og er fjernet fra koden. Kilde: Image generation (OpenAI).
Variationer og iterationer
Det er sjældent at ramme det perfekte billede i første forsøg. Rigligt arbejde indebærer at generere variationer, sammenligne dem og derefter gradvist stramme prompten, indtil du når det ønskede resultat. Denne lektion giver dig de tre værktøjer til denne metode: variation ved genkørsel, variation ved at modificere prompten og iteration gennem successive forfinelser.
Generering af variationer over samme koncept
Den enkleste metode er at genkøre genereringen med samme prompt: GPT Image producerer et andet resultat hver gang. Dette er nyttigt i udforskningsfasen, hvor du endnu ikke ved, hvad du leder efter, og ønsker at se spændvidden af mulige fortolkninger af en idé.
from openai import OpenAI
import base64
client = OpenAI()
def generate_variations(prompt: str, n_variations: int, prefix: str):
"""Generer flere uafhængige variationer af samme 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} gemt: {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 ved at modificere prompten
Den forrige tilgang efterlader dig med tilfældighed; denne giver dig kontrol. Du fastlåser et invariant subjekt – her en dampende kaffekop på et træbord – og flytter kun én dimension: stemningen. De fem resultater bliver derefter sammenlignelige, da du ved præcis, hvad der adskiller dem. Det er forskellen mellem fem forsøg og et eksperiment.
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 ved at forfine prompten
Når resultatet ikke er tilfredsstillende, er den rigtige reaktion ikke at genkøre og håbe på held, men at tilføje den manglende begrænsning. Serien nedenfor viser denne progression i et gennemarbejdet eksempel: „Et logo til en fintech-startup” fortæller modellen ingenting; anden iteration afgrænser antallet af farver og baggrunden; tredje navngiver den visuelle metafor og paletten; fjerde går ned til hex-koder og stregtykkelse. Med hver gennemgang indsnævres rummet af mulige resultater, og reproducerbarheden øges.
from openai import OpenAI
import base64
client = OpenAI()
iterations = [
# Iteration 1: basis-prompt
"A logo for a fintech startup",
# Iteration 2: tilføjelse af visuelle begrænsninger
"A logo for a fintech startup, minimalist design, maximum two colors, transparent background",
# Iteration 3: stilpræcision
(
"Minimalist logo for a fintech startup, abstract geometric icon "
"evoking growth, navy blue and emerald green palette, no text, vector style"
),
# Iteration 4: fine justeringer
(
"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")
Automatiseret iterations-pipeline
Ved lidt længere projekter rækker menneskelig hukommelse ikke: efter femten billeder ved du ikke længere, hvilken prompt der producerede hvilket resultat. Den følgende pipeline strukturerer arbejdet i runder, genererer flere varianter per runde, navngiver filer sporbart og beholder den komplette historik over prompts i en JSON-fil. Det er denne historikfil, der gør opsætningen værdifuld: den lader dig gå tilbage og kapitalisere fra ét projekt til det næste.
from openai import OpenAI
import base64
import json
client = OpenAI()
def iteration_pipeline(brief: str, n_rounds: int = 3, n_per_round: int = 3):
"""
Iterations-pipeline: genererer flere varianter per runde,
beholder en historik over prompts og resultater.
"""
history = []
current_prompt = brief
for round_num in range(1, n_rounds + 1):
print(f"\n{'='*50}")
print(f"RUNDE {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
})
# Forfin prompten til næste runde
if round_num < n_rounds:
current_prompt += ", more details, better composition"
# Gem historikken
with open("pipeline_history.json", "w") as f:
json.dump(history, f, indent=2, ensure_ascii=False)
print(f"\nHistorik gemt: 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
)
Sammenligning af variationer i et katalog
At åbne ni PNG-filer én efter én i en fremviser muliggør ingen seriøs sammenligning. Generer i stedet en HTML-side, der viser dem side om side, med billeder kodet i base64, så filen er selvindholdende og kan deles som den er med en kunde 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"):
"""Opret en HTML-side med alle billeder side om 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"Katalog genereret: {output}")
images = sorted(glob("pipeline_r*_v*.png"))
generate_catalog(images, "Variationer — Ghibli-boghandel")
Iterationens disciplin
Nogle få principper adskiller produktiv iteration fra kostbart trial-and-error. Ændr kun én parameter ad gangen, ellers vil du aldrig vide, hvilken der forbedrede resultatet. Behold en historik over dine prompts og renders, som pipelinen ovenfor gør, for at kapitalisere i stedet for at starte forfra ved hvert projekt. Arbejd med quality: low gennem hele udforskningsfasen og skift til high først til det endelige render, ellers betaler du toppris for billeder, du alligevel kasserer. Når du blot søger hurtig diversitet, så foretræk et enkelt kald med parameteren n frem for en løkke af forespørgsler. Navngiv endelig dine filer beskrivende: det er en triviel detalje dag ét, men afgørende efter to hundrede billeder.
Anvend nu denne fulde sekvens på et emne efter eget valg – logo, illustration eller produktfoto. Generer tre varianter med en indledende prompt, forfin den prompt i lyset af resultaterne, generer tre nye varianter, og producer derefter det sammenlignende HTML-katalog over de seks billeder.