Kombinera bildgenerering med andra API-verktyg
På denna sida
Uppdatering 2 november 2026 — Bildmodeller.
gpt-image-1, modellen som denna kurs ursprungligen skrevs för, lades ner den 23 oktober 2026.gpt-image-1.5,gpt-image-1-miniochchatgpt-image-latestkommer att tas ur bruk den 1 december 2026. Exemplen använder nugpt-image-2.5-sunburst, som erbjuder högsta precision för redigering;gpt-image-2.5-flareär snabbare för standardgenerering. Båda modellerna stöder även kvalitetsinställningarnaxhighochmax. GPT Image-modeller returnerar alltid bilder i base64: parameternresponse_formatfrån äldre DALL·E-modeller stöds inte och har tagits bort från koden. Källa: Image generation (OpenAI).
Kombinera bildgenerering med andra API-verktyg
Isolerat sett är bildgenerering ett hantverksverktyg: du skriver en prompt, du får en fil. Den verkliga kraften uppstår när den blir ett steg i en automatiserad kedja – en språkmodell som skriver prompten, en visuell analys som beskriver en referensbild, eller ett lagringssystem som publicerar resultatet. I denna lektion visar vi hur du kopplar ihop dessa delar.
Låt en språkmodell skriva prompten
Dina användare eller kollegor skriver inte visuella prompter; de skriver briefs. “Jag behöver en bild till en artikel om AI inom vården, futuristisk men mänsklig” innehåller ingen komposition, belysning eller palett. Istället för att be dem lära sig vokabulären från föregående lektion, låter du en språkmodell hantera översättningen. Tilldela den rollen som art director i systemmeddelandet och kräv att den producerar promptens specifika lager, med strikta instruktioner om att inte output:a något annat. Annars får du en artig förklaring som du sedan måste skicka vidare till GPT Image.
from openai import OpenAI
import base64
client = OpenAI()
def text_to_image(brief: str, output: str):
"""
Tvåstegs-pipeline:
1. En LLM genererar den optimala visuella prompten
2. GPT Image skapar bilden
"""
# Steg 1: Generera den visuella prompten 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]}...")
# Steg 2: Generera bilden
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"
)
Illustrera en artikel från början till slut
En featureartikel behöver en omslagsbild och en illustration per avsnitt. Dessa bilder måste se sammanhängande ut utan att vara identiska. Funktionen illustrate_article tillämpar denna logik genom att återinföra stilen i varje prompt och upprepa artikelns titel varje gång, vilket ger hela uppsättningen tematisk enhetlighet. Två kostnadsbesparande detaljer förtjänar uppmärksamhet: omslaget genereras med kvaliteten high eftersom alla ser det och det delas ofta, medan avsnittsillustrationerna hålls på medium eftersom de visas mindre och längre ner på sidan. För de fem avsnitten i detta exempel om AI inom rekrytering skär denna avvägning kostnaderna utan att läsaren märker något.
from openai import OpenAI
import base64
import json
client = OpenAI()
def illustrate_article(title: str, sections: list[str], style: str, output_dir: str = "."):
"""
Genererar en header-illustration + en per avsnitt.
"""
results = []
# Omslagsbild
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}")
# Avsnittsillustrationer
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 en bild för att regenerera den annorlunda
Hur får du en vinterversion av ett sommarlandskap när du bara har filen, ingen mask och inga redigeringsverktyg? Gå via språket. Modellens vision analyserar bilden och producerar en beskrivning som är tillräckligt exakt för att fungera som en rekonstruktionsprompt – motiv, komposition, belysning, färger, stil, perspektiv, stämning. Du konkatenerar sedan din modifieringsinstruktion till denna beskrivning. Genereringsmodellen får en komplett textprompt där endast årstiden har ändrats, och du får en bild som är sammanhängande med originalet snarare än något orelaterat. Detta är också det mest tillförlitliga sättet att reproducera den visuella identiteten hos en referensbild som du inte kan redigera direkt.
from openai import OpenAI
import base64
client = OpenAI()
def analyze_and_vary(image_path: str, instruction: str, output: str):
"""
1. Analyserar en bild med GPT Vision
2. Genererar en variant baserad på analysen
"""
# Steg 1: Analysera bilden
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]}...")
# Steg 2: Generera en modifierad 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"
)
Bearbeta stora volymer i batchar
Att generera fem produktbilder i serie tar minuter; att generera femhundra sekventiellt tar hela natten och kraschar vid första nätverkshickan. Uppsättningen nedan löser båda problemen. Varje uppgift är en fristående ordbok som bär sitt ID, sin prompt, sin utdatafil och sina inställningar. Worker-funktionen lindar anropet i ett try-block som returnerar en status istället för att krascha hela batchen: en avvisad generering drar inte längre ner de andra fyrahundranittionio. ThreadPoolExecutor parallelliserar sedan körningen, men med en avsiktligt låg max_workers – tre i detta exempel – eftersom flaskhalsen inte är din maskin, utan API-kvoterna. Den slutliga rapporten räknar framgångar och misslyckanden så att du vet vad du ska försöka 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:
"""Genererar en enskild bild från en uppgift."""
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):
"""Kör en batch av genereringar med kontrollerad parallellism."""
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
# Definiera en batch av uppgifter
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)
Publicera direkt till lagring
Att skriva PNG-filen till disken på maskinen som kör skriptet är bara meningsfullt under utveckling. I produktion måste bilden hamna där din webbplats hämtar den, och en omväg via det lokala filsystemet blir en onödig felpunkt. Formatet b64_json passar denna borttagning väl: dekoderade bytes lindas i ett BytesIO-objekt och pushas direkt till bucketen, med en explicit ContentType – utan vilken webbläsare skulle erbjuda en nedladdning istället för att visa bilden. Funktionen returnerar den publika URL:en, vilket är det ditt CMS faktiskt behöver.
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):
"""Genererar en bild och laddar upp den direkt till 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
# Exempel
url = generate_and_store_s3(
"Mobile app icon: open book with stars, flat design",
"my-image-bucket",
"generated/app_icon_v1.png"
)
Vad som håller en pipeline uppe
De fem pipelines i denna lektion delar samma konstruktionshygien. Varje steg gör en sak, vilket låter dig byta ut prompt-skrivning eller lagring utan att röra resten. Varje steg hanterar sina egna fel; annars skulle ett modereringsavslag mitt i en batch dra ner hela kedjan – det är precis vad try-blocket i generate_one_image förhindrar. Parallellismen hålls strypt för att respektera hastighetsbegränsningar, och på denna punkt kostar försiktighet mindre än återhämtning efter en tillfällig avstängning.
Två mindre synliga men lika avgörande vanor återstår. Logga de prompter som faktiskt skickas, särskilt när de skrivs av en språkmodell: utan denna logg blir en bild du älskar oreplicerbar vid andra körningen. Och cacha resultat när samma prompt kan återkomma, vilket nästa lektion formaliserar till ett komplett system.
Sätt nu ihop din egen fullständiga kedja: den tar en artikeltitel som indata, ber en språkmodell om tre beskrivningar av relevanta visuella element, genererar de tre bilderna parallellt och producerar en sammanfattande JSON som länkar varje prompt till dess fil. Då har du allt som behövs för att illustrera en hel blogg utan manuellt ingripande.