Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Combineren van het genereren van afbeeldingen met andere API-tools

Les 10 van 12 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Combineren van het genereren van afbeeldingen met andere API-tools
  2. Laat een taalmodel de prompt schrijven
  3. Een artikel van begin tot eind illustreren
  4. Een afbeelding beschrijven om deze anders te regenereren
  5. Grote volumes in batches verwerken
  6. Direct publiceren naar opslag
  7. Belangrijkste punten

Update 2 november 2026 — Afbeeldingsmodellen. gpt-image-1, het model waarvoor deze cursus oorspronkelijk is geschreven, is op 23 oktober 2026 stopgezet. gpt-image-1.5, gpt-image-1-mini en chatgpt-image-latest worden 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 ondersteund en is uit de code verwijderd. Bron: Image generation (OpenAI).

Combineren van het genereren van afbeeldingen met andere API-tools

Op zichzelf staand is het genereren van afbeeldingen een ambachtelijk hulpmiddel: u schrijft een prompt en ontvangt een bestand. De ware kracht komt naar voren wanneer het één stap wordt in een geautomatiseerde keten: een taalmodel dat de prompt schrijft, een visie-analyse die een referentieafbeelding beschrijft, of opslag die het resultaat publiceert. Deze les laat u zien hoe u deze onderdelen met elkaar verbindt.

Laat een taalmodel de prompt schrijven

Uw gebruikers of collega’s schrijven geen visuele prompts; ze schrijven briefings. “Ik heb een afbeelding nodig voor een artikel over AI in de gezondheidszorg, futuristisch maar menselijk” bevat geen compositie, belichting of palet. In plaats van hen te vragen de vocabulaire uit de vorige les te leren, zet u een taalmodel in om de vertaling te verzorgen. Ken het de rol van art director toe in het systeembericht en verplicht het om de specifieke lagen van de prompt te produceren, met strikte instructies om niets anders uit te voeren. Anders ontvangt u een beleefde uitleg die u vervolgens weer naar GPT Image moet sturen.

from openai import OpenAI
import base64

client = OpenAI()

def text_to_image(brief: str, output: str):
    """
    Twee-staps pijplijn:
    1. Een LLM genereert de optimale visuele prompt
    2. GPT Image maakt de afbeelding
    """
    # Stap 1: Genereer de visuele prompt met een 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]}...")

    # Stap 2: Genereer de afbeelding
    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"
)

Een artikel van begin tot eind illustreren

Een feature-artikel heeft een coverafbeelding en één illustratie per sectie nodig. Deze afbeeldingen moeten samenhangend ogen zonder identiek te zijn. De functie illustrate_article past deze logica toe door de stijl in elke prompt opnieuw te injecteren en de titel van het artikel telkens te herhalen, waardoor de volledige set thematische eenheid krijgt. Twee kostenbesparende details verdienen aandacht: de cover wordt gegenereerd met high kwaliteit omdat iedereen deze ziet en deze vaak wordt gedeeld, terwijl sectie-illustraties op medium blijven omdat ze kleiner en lager op de pagina worden weergegeven. Voor de vijf secties in dit voorbeeld over AI in werving snijdt deze afweging in de kosten zonder dat de lezer iets merkt.

from openai import OpenAI
import base64
import json

client = OpenAI()

def illustrate_article(title: str, sections: list[str], style: str, output_dir: str = "."):
    """
    Genereert een header-illustratie + één per sectie.
    """
    results = []

    # Coverafbeelding
    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}")

    # Sectie-illustraties
    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="."
)

Een afbeelding beschrijven om deze anders te regenereren

Hoe krijgt u een winterse versie van een zomerlandschap wanneer u alleen het bestand heeft, geen masker en geen bewerkingshulpmiddelen? Ga via taal. De visie van het model analyseert de afbeelding en produceert een beschrijving die nauwkeurig genoeg is om als reconstructie-prompt te dienen: onderwerp, compositie, belichting, kleuren, stijl, perspectief, sfeer. Vervolgens voegt u uw modificatie-instructie samen met deze beschrijving. Het generatiemodel ontvangt een volledige tekstprompt waarin alleen het seizoen is veranderd, en u krijgt een afbeelding die coherent is met het origineel in plaats van iets unrelated. Dit is ook de meest betrouwbare manier om de visuele identiteit van een referentieafbeelding te reproduceren die u niet direct kunt bewerken.

from openai import OpenAI
import base64

client = OpenAI()

def analyze_and_vary(image_path: str, instruction: str, output: str):
    """
    1. Analyseert een afbeelding met GPT Vision
    2. Genereert een variant op basis van de analyse
    """
    # Stap 1: Analyseer de afbeelding
    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]}...")

    # Stap 2: Genereer een gewijzigde 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"
)

Grote volumes in batches verwerken

Het genereren van vijf productvisuals in serie kost minuten; het sequentieel genereren van vijfhonderd kost de hele nacht en faalt bij de eerste netwerkstoring. De onderstaande opstelling lost beide problemen op. Elke taak is een op zichzelf staand dictionary dat zijn ID, prompt, uitvoerbestand en instellingen bevat. De worker-functie omhult de aanroep in een try-blok dat een status retourneert in plaats van de hele batch te laten crashen: een geweigerde generatie haalt niet langer de andere vierhonderdnegenennegentig onderuit. De ThreadPoolExecutor parallelleert vervolgens de uitvoering, maar met een bewust lage max_workers—drie in dit voorbeeld—omdat de bottleneck niet uw machine is, maar de API-quota. Het eindrapport talt successen en fouten, zodat u weet wat u opnieuw moet proberen.

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:
    """Genereert een enkele afbeelding vanuit een taak."""
    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):
    """Voert een batch generaties uit met gecontroleerde 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']}")

    # Rapportage
    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


# Definieer een batch taken
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)

Direct publiceren naar opslag

Het schrijven van de PNG naar de schijf van de machine die het script uitvoert, is alleen zinvol tijdens ontwikkeling. In productie moet de afbeelding terechtkomen waar uw site deze ophaalt, en een omweg via het lokale bestandssysteem wordt dan een onnodig faalpunt. Het b64_json-formaat leent zich goed voor deze verwijdering: gedecodeerde bytes worden verpakt in een BytesIO-object en direct naar de bucket gepusht, met een expliciete ContentType—zonder welke browsers een download zouden aanbieden in plaats van de afbeelding weer te geven. De functie retourneert de openbare URL, wat uw CMS daadwerkelijk nodig heeft.

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):
    """Genereert een afbeelding en uploadt deze direct naar 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


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

Belangrijkste punten

De vijf pijplijnen in deze les delen dezelfde bouwhygiëne. Elke stap doet één ding, waardoor u het schrijven van prompts of de opslag kunt vervangen zonder de rest aan te raken. Elke stap behandelt zijn eigen fouten; anders zou een weigering door moderatie midden in een batch de hele keten laten vallen—dat is precies wat de try in generate_one_image voorkomt. Parallelisme blijft gedrosseld om rate limits te respecteren, en op dit punt kost voorzichtigheid minder dan herstel na een tijdelijke ban.

Twee minder zichtbare maar even beslissende gewoonten blijven over. Log de prompts die daadwerkelijk zijn verzonden, vooral wanneer deze door een taalmodel zijn geschreven: zonder dit logboek wordt een afbeelding waar u dol op bent bij de tweede run niet-reproduceerbaar. En cache resultaten wanneer dezelfde prompt terug zou kunnen keren, wat de volgende les formaliseert tot een compleet systeem.

Stel nu uw eigen volledige keten samen: deze neemt een artikelstitel als input, vraagt een taalmodel om drie beschrijvingen van relevante visuals, genereert de drie afbeeldingen parallel en produceert een samenvattende JSON die elke prompt koppelt aan zijn bestand. U heeft dan alles wat nodig is om een volledige blog te illustreren zonder handmatige tussenkomst.