Kombiniranje ustvarjanja slik z drugimi orodji API
Na tej strani
Posodobitev 2. novembra 2026 — modeli za slike. Model
gpt-image-1, za katerega je bil ta tečaj prvotno napisan, je bil ukinjen 23. oktobra 2026. Modelagpt-image-1.5ingpt-image-1-miniterchatgpt-image-latestbodo upokojeni 1. decembra 2026. Primeri zdaj uporabljajogpt-image-2.5-sunburst, ki ponuja najvišjo natančnost pri urejanju;gpt-image-2.5-flareje hitrejši za standardno ustvarjanje. Oba modela podpirata tudi nastavitvi kakovostixhighinmax. Modeli GPT Image vedno vrnejo slike v formatu base64: parameterresponse_formatiz starejših modelov DALL·E ni podprt in je bil odstranjen iz kode. Vir: Ustvarjanje slik (OpenAI).
Kombiniranje ustvarjanja slik z drugimi orodji API
Samo po sebi je ustvarjanje slik obrtno orodje: napišeš poziv in dobiš datoteko. Njegova prava moč pride do izraza, ko postane en korak v avtomatizirani verigi – jezikovni model, ki napiše poziv, vizualna analiza, ki opiše referenčno sliko, ali shramba, ki objavi rezultat. Ta lekcija ti pokaže, kako povezati te dele skupaj.
Naj jezikovni model napiše poziv
Tvoji uporabniki ali sodelavci ne pišejo vizualnih pozivov; pišejo briefinge. „Potrebujem sliko za članek o umetni inteligenci v zdravstvu, futuristično, a človeško” ne vsebuje ničesar o kompoziciji, osvetlitvi ali paleti. Namesto da bi od njih zahtevali učenje besedišča iz prejšnje lekcije, vstavi jezikovni model, ki bo poskrbel za prevod. Dodeli mu vlogo umetniškega direktorja v sistemskem sporočilu in zahtevaj, da proizvede specifične plasti poziva s strogimi navodili, naj ne izpiše ničesar drugega. V nasprotnem primeru boš prejel vljudno razlago, ki jo boš moral nato poslati modelu GPT Image.
from openai import OpenAI
import base64
client = OpenAI()
def text_to_image(brief: str, output: str):
"""
Dvostopenjski potek:
1. LLM ustvari optimalni vizualni poziv
2. GPT Image ustvari sliko
"""
# 1. korak: Ustvari vizualni poziv z 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]}...")
# 2. korak: Ustvari sliko
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"
)
Ilustracija članka od začetka do konca
Poljudni članek potrebuje naslovno sliko in po eno ilustracijo za vsak razdelek. Te slike morajo izgledati kohezivno, ne smejo pa biti identične. Funkcija illustrate_article uporablja to logiko tako, da v vsak poziv ponovno vbrizga slog in vsakič ponovi naslov članka, kar celotnemu nizu daje tematsko enotnost. Pozornost zaslužita dve podrobnosti, ki varčujeta s stroški: naslovnica se ustvari v kakovosti high, ker jo vidijo vsi in se pogosto deli, medtem ko ilustracije razdelkov ostanejo na ravni medium, saj so na strani prikazane manjše in nižje. Pri petih razdelkih v tem primeru o AI pri zaposlovanju ta kompromis zmanjša stroške, bralec pa ne opazi razlike.
from openai import OpenAI
import base64
import json
client = OpenAI()
def illustrate_article(title: str, sections: list[str], style: str, output_dir: str = "."):
"""
Ustvari naslovno ilustracijo in po eno za vsak razdelek.
"""
results = []
# Naslovna slika
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}")
# Ilustracije razdelkov
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="."
)
Opis slike za njeno drugačno regeneracijo
Kako dobiti zimsko različico poletne pokrajine, ko imaš na voljo le datoteko, brez maske in brez orodij za urejanje? Preko jezika. Vizija modela analizira sliko in ustvari opis, ki je dovolj natančen, da služi kot poziv za rekonstrukcijo – subjekt, kompozicija, osvetlitev, barve, slog, perspektiva, razpoloženje. Temu opisu nato dodaš svoje navodilo za spremembo. Model za ustvarjanje prejme popoln besedni poziv, kjer se je spremenila le letna doba, in dobiš sliko, ki je koherentna z izvirnikom, namesto nekaj nepovezanega. To je tudi najbolj zanesljiv način za reprodukcijo vizualne identitete referenčne slike, ki je ne moreš neposredno urejati.
from openai import OpenAI
import base64
client = OpenAI()
def analyze_and_vary(image_path: str, instruction: str, output: str):
"""
1. Analizira sliko z GPT Vision
2. Ustvari varianto na podlagi analize
"""
# 1. korak: Analiziraj sliko
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]}...")
# 2. korak: Ustvari spremenjeno varianto
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"
)
Obdelava velikih količin v serijah
Ustvarjanje petih vizualizacij izdelkov zaporedoma traja minute; ustvarjanje petsto zaporedoma traja vso noč in se ustavi ob prvi omrežni težavi. Spodnja nastavitev reši obe težavi. Vsaka naloga je samostojen slovar, ki nosi svoj ID, poziv, izhodno datoteko in nastavitve. Funkcija delavca ovije klic v blok try, ki vrne status namesto, da bi sesul celotno serijo: zavrnjeno ustvarjanje ne potegne dol ostalih štiristo devetindevetdesetih. ThreadPoolExecutor nato vzporedi izvajanje, vendar z namerno nizkim max_workers – v tem primeru tremi – ker ozko grlo ni tvoj računalnik, temveč kvote API-ja. Končno poročilo prešteje uspehe in napake, da veš, kaj je treba ponoviti.
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:
"""Ustvari eno sliko iz naloge."""
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):
"""Izvede serijo ustvarjanj z nadzorovano vzporednostjo."""
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']}")
# Poročilo
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
# Definiraj serijo nalog
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)
Neposredna objava v shrambo
Zapisovanje PNG na disk stroja, ki izvaja skripto, ima smisel le med razvojem. V proizvodnem okolju mora slika pristati tam, kjer jo bo tvoja spletna stran pridobila, obhod prek lokalnega datotečnega sistema pa postane nepotrebna točka odpovedi. Format b64_json se za to odstranitev dobro obnese: dekodirani bajti so oviti v objekt BytesIO in neposredno potisnjeni v vsebnik (bucket) z eksplicitnim ContentType – brez tega bi brskalniki ponudili prenos namesto prikaza slike. Funkcija vrne javni URL, kar je tisto, kar tvoj CMS dejansko potrebuje.
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):
"""Ustvari sliko in jo neposredno naloži v 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
# Primer
url = generate_and_store_s3(
"Mobile app icon: open book with stars, flat design",
"my-image-bucket",
"generated/app_icon_v1.png"
)
Kaj ohranja potek delovanja stabilnega
Pet potekov delovanja v tej lekciji si deli isto higieno gradnje. Vsak korak opravi eno stvar, kar ti omogoča zamenjavo pisanja pozivov ali shranjevanja, ne da bi se dotaknil ostalega. Vsak korak obravnava svoje napake; v nasprotnem primeru bi zavrnitev zaradi moderacije sredi serije sesula celotno verigo – točno to preprečuje try v generate_one_image. Vzporednost ostaja omejena, da se spoštujejo omejitve hitrosti, in pri tej točki previdnost stane manj kot obnovitev po začasnem bloku.
Ostaneta še dve manj vidni, a enako odločilni navadi. Beleži dejansko poslane pozive, še posebej, ko jih napiše jezikovni model: brez tega dnevnika slika, ki ti je všeč, ob drugem zagonu postane nereproduciabilna. In predpomni rezultate, kadar se lahko vrne isti poziv, kar bo naslednja lekcija formalizirala v popoln sistem.
Zdaj sestavi svojo lastno celotno verigo: kot vhod vzame naslov članka, od jezikovnega modela zahteva tri opise ustreznih vizualizacij, vzporedno ustvari tri slike in proizvede povzetek JSON, ki povezuje vsak poziv z njegovo datoteko. Nato boš imel vse potrebno za ilustracijo celotnega bloga brez ročnega posredovanja.