Kombinér billedgenerering med andre API-værktøjer
På denne side
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-miniogchatgpt-image-latestudgår den 1. december 2026. Eksemplerne bruger nugpt-image-2.5-sunburst, der tilbyder højeste præcision til redigering;gpt-image-2.5-flareer hurtigere til standardgenerering. Begge modeller understøtter også kvalitetsindstillingernexhighogmax. GPT Image-modeller returnerer altid billeder i base64: parameterenresponse_formatfra æ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.