Variaties en iteraties
Op deze pagina
Bijgewerkt op 2 november 2026 — Imagemodellen.
gpt-image-1, het model waarvoor deze cursus oorspronkelijk is geschreven, is op 23 oktober 2026 stopgezet. Daarnaast wordengpt-image-1.5,gpt-image-1-minienchatgpt-image-latestop 1 december 2026 buiten gebruik gesteld. De voorbeelden gebruiken nugpt-image-2.5-sunburst, dat de hoogste precisie biedt voor bewerkingen;gpt-image-2.5-flareis sneller voor standaardgeneratie. Beide modellen ondersteunen ook de kwaliteitsinstellingenxhighenmax. GPT Image-modellen retourneren afbeeldingen altijd in base64: de parameterresponse_formatvan oudere DALL·E-modellen wordt niet langer geaccepteerd en is uit de code verwijderd. Bron: Image generation (OpenAI).
Variaties en iteraties
Het is zeldzaam dat u in één keer de perfecte afbeelding krijgt. Echt werk bestaat uit het genereren van variaties, het vergelijken ervan en het vervolgens stap voor verscherpen van de prompt totdat u het gewenste resultaat bereikt. Deze les geeft u de drie hulpmiddelen voor deze methode: variatie door opnieuw uitvoeren, variatie door aanpassing van de prompt, en iteratie door opeenvolgende verfijning.
Variaties van hetzelfde concept genereren
De eenvoudigste methode is om de generatie opnieuw uit te voeren met dezelfde prompt: GPT Image produceert elke keer een ander resultaat. Dit is nuttig aan het begin van een verkenning, wanneer u nog niet precies weet wat u zoekt en het bereik van mogelijke interpretaties van een idee wilt zien.
from openai import OpenAI
import base64
client = OpenAI()
def generate_variations(prompt: str, n_variations: int, prefix: str):
"""Genereer meerdere onafhankelijke variaties van dezelfde 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"Variatie {i+1} opgeslagen: {path}")
return paths
variations = generate_variations(
prompt="Illustratie van een tuinierrobot die bloemen water geeft, kinderlijke en kleurrijke stijl",
n_variations=5,
prefix="gardener_robot"
)
Variaties door de prompt aan te passen
De vorige aanpak laat u over aan het toeval; deze geeft u controle. U fixeert een invariant onderwerp—hier een dampende koffiekop op een houten tafel—en wijzigt slechts één dimensie: de sfeer. De vijf resultaten worden dan vergelijkbaar, omdat u precies weet wat hen onderscheidt. Dit is het verschil tussen vijf pogingen en een experiment.
from openai import OpenAI
import base64
client = OpenAI()
base_prompt = "Dampende koffiekop op een houten tafel"
moods = [
"zacht ochtendlicht, warme tinten",
"Parijse cafésfeer, zwart-wit",
"popartstijl, verzadigde kleuren",
"Scandinavisch minimalistisch, witte achtergrond",
"gezellige wintersfeer, bokeh-slingerlichtjes",
]
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"Sfeer: {mood[:30]}... → {path}")
Iteratie door de prompt te verfijnen
Wanneer het resultaat niet bevredigend is, is de juiste reactie niet om opnieuw te starten en op meer geluk te hopen, maar om de ontbrekende beperking toe te voegen. De onderstaande reeks toont deze progressie in een uitgewerkt voorbeeld: “Een logo voor een fintech-startup” vertelt het model niets; de tweede iteratie begrenst het aantal kleuren en de achtergrond; de derde noemt de visuele metafoor en het palet; de vierde gaat tot op hex-codes en lijndikte. Met elke stap wordt de ruimte van mogelijke resultaten smaller en neemt de reproduceerbaarheid toe.
from openai import OpenAI
import base64
client = OpenAI()
iterations = [
# Iteratie 1: basisprompt
"Een logo voor een fintech-startup",
# Iteratie 2: visuele beperkingen toevoegen
"Een logo voor een fintech-startup, minimalistisch ontwerp, maximaal twee kleuren, transparante achtergrond",
# Iteratie 3: stijlprecisie
(
"Minimalistisch logo voor een fintech-startup, abstract geometrisch pictogram "
"dat groei oproept, marineblauw en smaragdgroen palet, geen tekst, vectorstijl"
),
# Iteratie 4: fijne aanpassingen
(
"Minimalistisch logo voor een fintech-startup, abstract geometrisch pictogram: "
"twee in elkaar grijpende pijlen die een ruit vormen, marineblauw (#1B2A4A) en "
"smaragdgroen (#2ECC71), 2px dunne lijn, witte achtergrond, scherpe vectorrender, gecentreerd"
),
]
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"Iteratie {i+1}: {prompt[:60]}...")
print(f" → {path}\n")
Geautomatiseerde iteratiepijplijn
Bij een iets langer project is het menselijk geheugen niet toereikend: na vijftien afbeeldingen weet u niet meer welke prompt welk resultaat opleverde. De volgende pijplijn structureert het werk in rondes, genereert per ronde meerdere varianten, geeft bestanden traceerbare namen en bewaart de volledige geschiedenis van prompts in een JSON-bestand. Dit geschiedenisbestand is wat de opzet waardevol maakt: het stelt u in staat om terug te gaan en kennis over te dragen van het ene project naar het volgende.
from openai import OpenAI
import base64
import json
client = OpenAI()
def iteration_pipeline(brief: str, n_rounds: int = 3, n_per_round: int = 3):
"""
Iteratiepijplijn: genereert meerdere varianten per ronde,
houdt een geschiedenis bij van prompts en resultaten.
"""
history = []
current_prompt = brief
for round_num in range(1, n_rounds + 1):
print(f"\n{'='*50}")
print(f"RONDE {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
})
# Verfijn de prompt voor de volgende ronde
if round_num < n_rounds:
current_prompt += ", meer details, betere compositie"
# Sla de geschiedenis op
with open("pipeline_history.json", "w") as f:
json.dump(history, f, indent=2, ensure_ascii=False)
print(f"\nGeschiedenis opgeslagen: pipeline_history.json")
return history
iteration_pipeline(
brief="Illustratie van een onafhankelijke boekhandel van buitenaf gezien, herfstavond, Ghibli-stijl",
n_rounds=3,
n_per_round=3
)
Variaties vergelijken in een catalogus
Negen PNG-bestanden één voor één openen in een viewer staat geen serieuze vergelijking toe. Genereer in plaats daarvan een HTML-pagina die ze naast elkaar weergeeft, met afbeeldingen gecodeerd in base64, zodat het bestand op zichzelf staat en als zodanig gedeeld kan worden met een klant of art director.
import base64
from pathlib import Path
from glob import glob
def generate_catalog(images: list[str], title: str, output: str = "catalog.html"):
"""Maak een HTML-pagina met alle afbeeldingen naast elkaar."""
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"Catalogus gegenereerd: {output}")
images = sorted(glob("pipeline_r*_v*.png"))
generate_catalog(images, "Variaties — Ghibli-boekhandel")
De discipline van iteratie
Enkele principes scheiden productieve iteratie van kostbaar trial-and-error. Wijzig slechts één parameter tegelijk, anders weet u nooit welke het resultaat heeft verbeterd. Houd een geschiedenis bij van uw prompts en renders, zoals de bovenstaande pijplijn doet, om kennis op te bouwen in plaats van bij elk project weer bij nul te beginnen. Werk tijdens de hele verkenningsfase met quality: low en schakel pas over op high voor de uiteindelijke render, anders betaalt u de hoofdprijs voor afbeeldingen die u toch weggooit. Wanneer u simpelweg op zoek bent naar snelle diversiteit, geef dan de voorkeur aan één aanroep met de parameter n boven een lus van verzoeken. Noem uw bestanden ten slotte beschrijvend: het is een triviaal detail op dag één, maar beslissend na tweehonderd afbeeldingen.
Pas deze volledige reeks nu toe op een onderwerp naar keuze—logo, illustratie of productfoto. Genereer drie varianten met een initiële prompt, verfijn die prompt op basis van de resultaten, genereer drie nieuwe varianten en produceer vervolgens de vergelijkende HTML-catalogus van de zes afbeeldingen.