Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Variationer og iterationer

Lektion 5 af 12 Opdateret 2. november 2026 Udvikler
På denne side
  1. Variationer og iterationer
  2. Generering af variationer over samme koncept
  3. Variationer ved at modificere prompten
  4. Iteration ved at forfine prompten
  5. Automatiseret iterations-pipeline
  6. Sammenligning af variationer i et katalog
  7. Iterationens disciplin

Opdateret 2. november 2026 — Billedmodeller. gpt-image-1, modellen som dette kursus oprindeligt blev skrevet til, blev udfaset 23. oktober 2026. Derudover vil gpt-image-1.5, gpt-image-1-mini og chatgpt-image-latest blive trukket tilbage 1. december 2026. Eksemplerne bruger nu gpt-image-2.5-sunburst, som tilbyder højeste præcision til redigering; gpt-image-2.5-flare er hurtigere til standardgenerering. Begge modeller understøtter også kvalitetsindstillingerne xhigh og max. GPT Image-modeller returnerer altid billeder i base64: parameteren response_format fra æ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.