Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Kombinér billedgenerering med andre API-værktøjer

Lektion 10 af 12 Opdateret 2. november 2026 Udvikler
På denne side
  1. Kombinér billedgenerering med andre API-værktøjer
  2. Lad en sprogmodel skrive prompten
  3. Illustrér en artikel fra ende til anden
  4. Beskriv et billede for at regenerere det anderledes
  5. Behandl store volumener i batches
  6. Publicér direkte til lager
  7. Vigtige pointer

Opdatering 2. november 2026 — Billedmodeller. gpt-image-1, som dette kursus oprindeligt blev skrevet til, blev afviklet den 23. oktober 2026. gpt-image-1.5, gpt-image-1-mini og chatgpt-image-latest udgår den 1. december 2026. Eksemplerne bruger nu gpt-image-2.5-sunburst, der 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 understøttes ikke og er fjernet fra koden. Kilde: Image generation (OpenAI).

Kombinér billedgenerering med andre API-værktøjer

Isoleret set er billedgenerering et håndværksværktøj: du skriver en prompt, og du får en fil. Den virkelige styrke viser sig, når det bliver ét led i en automatiseret kæde – en sprogmodel, der skriver prompten, en visuel analyse, der beskriver et referencebillede, eller et lager, der publicerer resultatet. Denne lektion viser dig, hvordan du kobler disse dele sammen.

Lad en sprogmodel skrive prompten

Dine brugere eller kolleger skriver ikke visuelle prompts; de skriver briefs. „Jeg har brug for et billede til en artikel om AI i sundhedsvæsenet, futuristisk men menneskeligt” indeholder ingen komposition, belysning eller farvepalet. I stedet for at bede dem lære ordforrådet fra den forrige lektion, indsætter du en sprogmodel til at håndtere oversættelsen. Tildel den rollen som art director i systembeskeden, og kræv, at den producerer de specifikke lag i prompten med strenge instrukser om ikke at outputte andet. Ellers modtager du en høflig forklaring, som du derefter skulle sende videre til GPT Image.

from openai import OpenAI
import base64

client = OpenAI()

def text_to_image(brief: str, output: str):
    """
    To-trins pipeline:
    1. En LLM genererer den optimale visuelle prompt
    2. GPT Image skaber billedet
    """
    # Trin 1: Generér den visuelle prompt med en LLM
    completion = client.chat.completions.create(
        model="gpt-5.6-luna",
        messages=[
            {
                "role": "system",
                "content": (
                    "You are an expert art director. "
                    "Based on a brief, generate a detailed prompt for an "
                    "image generation model. Include: subject, composition, lighting, "
                    "style, perspective, color palette. "
                    "Respond only with the prompt, no explanation."
                )
            },
            {"role": "user", "content": brief}
        ]
    )

    visual_prompt = completion.choices[0].message.content
    print(f"Generated prompt: {visual_prompt[:100]}...")

    # Trin 2: Generér billedet
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=visual_prompt,
        size="1536x1024",
        quality="high",
    )

    data = base64.b64decode(response.data[0].b64_json)
    with open(output, "wb") as f:
        f.write(data)
    print(f"Image generated: {output}")
    return visual_prompt


prompt = text_to_image(
    "I need an image for an article on artificial intelligence "
    "in healthcare. Futuristic but human.",
    "ai_health.png"
)

Illustrér en artikel fra ende til anden

En featureartikel har brug for et forsidebillede og én illustration pr. sektion. Disse billeder skal se sammenhængende ud uden at være identiske. Funktionen illustrate_article anvender denne logik ved at genindsætte stilen i hver prompt og gentage artiklens titel hver gang, hvilket giver hele sættet tematisk enhed. To detaljer, der sparer omkostninger, fortjener opmærksomhed: forsiden genereres med kvaliteten high, fordi alle ser den, og den deles ofte, mens sektionsillustrationer holdes på medium, da de vises mindre og længere nede på siden. For de fem sektioner i dette eksempel om AI i rekruttering reducerer denne afvejning regningen, uden at læseren lægger mærke til noget.

from openai import OpenAI
import base64
import json

client = OpenAI()

def illustrate_article(title: str, sections: list[str], style: str, output_dir: str = "."):
    """
    Genererer en header-illustration + én pr. sektion.
    """
    results = []

    # Forsidebillede
    header_prompt = (
        f"Cover image for an article titled \"{title}\", "
        f"{style} style, panoramic composition, "
        "no text in the image, professional"
    )

    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=header_prompt,
        size="1536x1024",
        quality="high",
    )

    path = f"{output_dir}/header.png"
    data = base64.b64decode(response.data[0].b64_json)
    with open(path, "wb") as f:
        f.write(data)
    results.append({"type": "header", "path": path})
    print(f"Header: {path}")

    # Sektionsillustrationer
    for i, section in enumerate(sections):
        section_prompt = (
            f"Illustration for the section \"{section}\" "
            f"of an article on \"{title}\", "
            f"{style} style, rectangular format, "
            "conceptual illustration without text"
        )

        response = client.images.generate(
            model="gpt-image-2.5-sunburst",
            prompt=section_prompt,
            size="1536x1024",
            quality="medium",
        )

        path = f"{output_dir}/section_{i+1}.png"
        data = base64.b64decode(response.data[0].b64_json)
        with open(path, "wb") as f:
            f.write(data)
        results.append({"type": f"section_{i+1}", "section": section, "path": path})
        print(f"Section {i+1} ({section[:30]}...) : {path}")

    return results


illustrate_article(
    title="5 Ways AI Is Transforming Recruitment",
    sections=[
        "Automatic CV Screening",
        "AI-Analyzed Video Interviews",
        "Smart Candidate-Job Matching",
        "Reducing Recruitment Bias",
        "Personalized Onboarding",
    ],
    style="3D isometric illustration, blue and violet tones",
    output_dir="."
)

Beskriv et billede for at regenerere det anderledes

Hvordan får du en vinterversion af et sommerlandskab, når du kun har filen, ingen maske og ingen redigeringsværktøjer? Gå vejen om sproget. Modellens vision analyserer billedet og producerer en beskrivelse, der er præcis nok til at fungere som en rekonstruktionsprompt – motiv, komposition, belysning, farver, stil, perspektiv, stemning. Derefter sammenkæder du din ændringsinstruks med denne beskrivelse. Genereringsmodellen modtager en komplet tekstprompt, hvor kun årstiden er ændret, og du får et billede, der er sammenhængende med originalen, frem for noget urelateret. Dette er også den mest pålidelige måde at reproducere den visuelle identitet af et referencebillede, som du ikke kan redigere direkte.

from openai import OpenAI
import base64

client = OpenAI()

def analyze_and_vary(image_path: str, instruction: str, output: str):
    """
    1. Analyserer et billede med GPT Vision
    2. Genererer en variant baseret på analysen
    """
    # Trin 1: Analysér billedet
    with open(image_path, "rb") as f:
        image_b64 = base64.b64encode(f.read()).decode()

    analysis = client.chat.completions.create(
        model="gpt-5.6-luna",
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "text",
                        "text": (
                            "Describe this image in detail so an image "
                            "generation model can reproduce it faithfully. "
                            "Include: subject, composition, lighting, colors, style, "
                            "perspective, mood. Be very precise."
                        )
                    },
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:image/png;base64,{image_b64}"
                        }
                    }
                ]
            }
        ]
    )

    description = analysis.choices[0].message.content
    print(f"Analysis: {description[:150]}...")

    # Trin 2: Generér en modificeret variant
    variant_prompt = f"{description}. Requested modification: {instruction}"

    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=variant_prompt,
        size="1024x1024",
        quality="high",
    )

    data = base64.b64decode(response.data[0].b64_json)
    with open(output, "wb") as f:
        f.write(data)
    print(f"Variant generated: {output}")


analyze_and_vary(
    "original_landscape.png",
    "Change the season from summer to winter, with snow on roofs and trees",
    "winter_landscape.png"
)

Behandl store volumener i batches

At generere fem produktvisualiseringer i serie tager minutter; at generere fem hundrede sekventielt tager hele natten og bryder sammen ved det første netværks hik. Opsætningen nedenfor løser begge problemer. Hver opgave er en selvstændig ordbog, der bærer sit ID, sin prompt, output-fil og indstillinger. Worker-funktionen pakker kaldet ind i en try-blok, der returnerer en status i stedet for at få hele batchet til at crashe: en afvist generering vælter ikke de andre fire hundrede og nioghalvfems. ThreadPoolExecutor paralleliserer derefter udførelsen, men med et bevidst lavt max_workers – tre i dette eksempel – fordi flaskehalsen ikke er din maskine, men API-kvoterne. Den endelige rapport tæller succeser og fejl, så du ved, hvad du skal prøve igen.

from openai import OpenAI
import base64
import json
import time
from concurrent.futures import ThreadPoolExecutor, as_completed

client = OpenAI()

def generate_one_image(task: dict) -> dict:
    """Genererer et enkelt billede fra en opgave."""
    try:
        response = client.images.generate(
            model="gpt-image-2.5-sunburst",
            prompt=task["prompt"],
            size=task.get("size", "1024x1024"),
            quality=task.get("quality", "medium"),
        )

        data = base64.b64decode(response.data[0].b64_json)
        with open(task["output"], "wb") as f:
            f.write(data)

        return {"id": task["id"], "status": "ok", "path": task["output"]}

    except Exception as e:
        return {"id": task["id"], "status": "error", "error": str(e)}


def batch_generation(tasks: list[dict], max_parallel: int = 3):
    """Udfører en batch af genereringer med kontrolleret parallelisme."""
    results = []

    with ThreadPoolExecutor(max_workers=max_parallel) as executor:
        futures = {
            executor.submit(generate_one_image, task): task
            for task in tasks
        }

        for future in as_completed(futures):
            result = future.result()
            results.append(result)
            status = result["status"]
            print(f"  [{status}] {result['id']}")

    # Rapport
    ok = sum(1 for r in results if r["status"] == "ok")
    errors = sum(1 for r in results if r["status"] == "error")
    print(f"\nFinished: {ok} ok, {errors} errors out of {len(tasks)} tasks")

    return results


# Definer en batch af opgaver
tasks = [
    {
        "id": f"product_{i}",
        "prompt": f"E-commerce product photo: {product}, white background, studio",
        "output": f"batch_product_{i}.png",
        "quality": "high"
    }
    for i, product in enumerate([
        "rose gold watch",
        "aviator sunglasses",
        "braided leather bracelet",
        "solitaire diamond ring",
        "cultured pearl necklace",
    ])
]

results = batch_generation(tasks, max_parallel=3)

Publicér direkte til lager

At skrive PNG-filen til disken på den maskine, der kører scriptet, giver kun mening under udvikling. I produktion skal billedet lande dér, hvor dit site vil hente det, og et detour gennem det lokale filsystem bliver et unødvendigt fejlpunkt. Formatet b64_json egner sig godt til denne fjernelse: dekodede bytes pakkes ind i et BytesIO-objekt og push’es direkte til bucket’en med en eksplicit ContentType – uden hvilken browsere ville tilbyde et download i stedet for at vise billedet. Funktionen returnerer den offentlige URL, hvilket er det, dit CMS faktisk har brug for.

from openai import OpenAI
import base64
import boto3
from io import BytesIO

client = OpenAI()

def generate_and_store_s3(prompt: str, bucket: str, key: str):
    """Genererer et billede og uploader det direkte til S3."""
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=prompt,
        size="1024x1024",
        quality="high",
    )

    image_data = base64.b64decode(response.data[0].b64_json)

    s3 = boto3.client("s3")
    s3.upload_fileobj(
        BytesIO(image_data),
        bucket,
        key,
        ExtraArgs={"ContentType": "image/png"}
    )

    url = f"https://{bucket}.s3.amazonaws.com/{key}"
    print(f"Image stored on S3: {url}")
    return url


# Eksempel
url = generate_and_store_s3(
    "Mobile app icon: open book with stars, flat design",
    "my-image-bucket",
    "generated/app_icon_v1.png"
)

Vigtige pointer

De fem pipelines i denne lektion deler den samme konstruktionshygiejne. Hvert trin gør én ting, så du kan udskifte prompt-skrivning eller lager uden at røre resten. Hvert trin håndterer sine egne fejl; ellers vil en afvisning fra moderation midt i en batch vælte hele kæden – det er præcis det, try-blokken i generate_one_image forhindrer. Parallelisme holdes tilbage for at respektere rate limits, og på dette punkt koster forsigtighed mindre end genopretning efter en midlertidig udelukkelse.

To mindre synlige, men lige så afgørende vaner tilbagebliver. Log de prompts, der faktisk sendes, især når de er skrevet af en sprogmodel: uden denne log bliver et billede, du elsker, ureproducerbart ved andet kørsel. Og cache resultater, når den samme prompt kan dukke op igen, hvilket næste lektion formaliserer til et komplet system.

Saml nu din egen fulde kæde: den tager en artikeltitel som input, beder en sprogmodel om tre beskrivelser af relevante visualiseringer, genererer de tre billeder parallelt og producerer et JSON-resumé, der linker hver prompt til dens fil. Så har du alt, hvad der skal til for at illustrere en hel blog uden manuel indgriben.