Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Variaties en iteraties

Les 5 van 12 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Variaties en iteraties
  2. Variaties van hetzelfde concept genereren
  3. Variaties door de prompt aan te passen
  4. Iteratie door de prompt te verfijnen
  5. Geautomatiseerde iteratiepijplijn
  6. Variaties vergelijken in een catalogus
  7. De discipline van iteratie

Bijgewerkt op 2 november 2026 — Imagemodellen. gpt-image-1, het model waarvoor deze cursus oorspronkelijk is geschreven, is op 23 oktober 2026 stopgezet. Daarnaast worden gpt-image-1.5, gpt-image-1-mini en chatgpt-image-latest op 1 december 2026 buiten gebruik gesteld. De voorbeelden gebruiken nu gpt-image-2.5-sunburst, dat de hoogste precisie biedt voor bewerkingen; gpt-image-2.5-flare is sneller voor standaardgeneratie. Beide modellen ondersteunen ook de kwaliteitsinstellingen xhigh en max. GPT Image-modellen retourneren afbeeldingen altijd in base64: de parameter response_format van 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.