Kombinace generování obrázků s dalšími nástroji API
Na této stránce
Aktualizace 2. listopadu 2026 — Modely obrázků. Model
gpt-image-1, pro který byl tento kurz původně napsán, byl ukončen 23. října 2026. Modelygpt-image-1.5,gpt-image-1-miniachatgpt-image-latestbudou vyřazeny z provozu 1. prosince 2026. Příklady nyní využívajígpt-image-2.5-sunburst, který nabízí nejvyšší přesnost pro úpravy;gpt-image-2.5-flareje rychlejší pro standardní generování. Obě modely také podporují nastavení kvalityxhighamax. Modely GPT Image vždy vracejí obrázky v base64: parametrresponse_formatze starších modelů DALL·E není podporován a byl z kódu odstraněn. Zdroj: Image generation (OpenAI).
Kombinace generování obrázků s dalšími nástroji API
Samotné generování obrázků je řemeslný nástroj: napíšeš prompt a dostaneš soubor. Jeho skutečná síla se projeví, když se stane jedním článkem v automatizovaném řetězci – jazykový model, který píše prompt, analýza vidění, která popisuje referenční obrázek, nebo úložiště, které výsledek publikuje. Tato lekce ti ukáže, jak tyto díly propojit.
Nech jazykový model napsat prompt
Tvoji uživatelé nebo kolegové nepíší vizuální prompty; píší zadání. „Potřebuji obrázek pro článek o AI ve zdravotnictví, futuristický, ale lidský“ neobsahuje nic o kompozici, osvětlení nebo paletě barev. Místo toho, abys po nich žádal, aby se naučili slovník z předchozí lekce, vlož do procesu jazykový model, který se postará o překlad. Přiřaď mu v systémové zprávě roli art direktora a požaduj, aby vytvořil specifické vrstvy promptu, s přísným pokynem, aby nevytvořil nic jiného. Jinak obdržíš zdvořilé vysvětlení, které bys pak musel posílat modelu GPT Image.
from openai import OpenAI
import base64
client = OpenAI()
def text_to_image(brief: str, output: str):
"""
Dvoukrokový pipeline:
1. LLM vygeneruje optimální vizuální prompt
2. GPT Image vytvoří obrázek
"""
# Krok 1: Vygenerování vizuálního promptu pomocí LLM
completion = client.chat.completions.create(
model="gpt-5.6-luna",
messages=[
{
"role": "system",
"content": (
"Jsi expertní art direktor. "
"Na základě zadání vygeneruj podrobný prompt pro "
"model generování obrázků. Zahrň: námět, kompozici, osvětlení, "
"styl, perspektivu, barevnou paletu. "
"Odpověz pouze promptem, žádné vysvětlení."
)
},
{"role": "user", "content": brief}
]
)
visual_prompt = completion.choices[0].message.content
print(f"Vygenerovaný prompt: {visual_prompt[:100]}...")
# Krok 2: Generování obrázku
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"Obrázek vygenerován: {output}")
return visual_prompt
prompt = text_to_image(
"Potřebuji obrázek pro článek o umělé inteligenci "
"ve zdravotnictví. Futuristický, ale lidský.",
"ai_health.png"
)
Ilustrace článku od začátku do konce
Obsáhlý článek potřebuje úvodní obrázek a jednu ilustraci na každou sekci. Tyto obrázky musí působit soudržně, aniž by byly totožné. Funkce illustrate_article aplikuje tuto logiku tím, že do každého promptu znovu vkládá styl a při každém opakuje název článku, čímž dodává celé sadě tematickou jednotu. Dva detaily šetřící náklady si zaslouží pozornost: úvodní obrázek je generován v kvalitě high, protože ho vidí každý a často se sdílí, zatímco ilustrace sekcí zůstávají na úrovni medium, protože se zobrazují menší a níže na stránce. U pěti sekcí v tomto příkladu o AI v náboru tento kompromis sníží účet, aniž by si čtenář něčeho všiml.
from openai import OpenAI
import base64
import json
client = OpenAI()
def illustrate_article(title: str, sections: list[str], style: str, output_dir: str = "."):
"""
Generuje úvodní ilustraci + jednu pro každou sekci.
"""
results = []
# Úvodní obrázek
header_prompt = (
f"Úvodní obrázek pro článek s názvem \"{title}\", "
f"styl {style}, panoramatická kompozice, "
"žádný text v obrázku, profesionální"
)
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"Záhlaví: {path}")
# Ilustrace sekcí
for i, section in enumerate(sections):
section_prompt = (
f"Ilustrace pro sekci \"{section}\" "
f"článku o \"{title}\", "
f"styl {style}, obdélníkový formát, "
"konceptuální ilustrace bez textu"
)
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"Sekce {i+1} ({section[:30]}...) : {path}")
return results
illustrate_article(
title="5 způsobů, jak AI transformuje nábor",
sections=[
"Automatické třídění životopisů",
"Video pohovory analyzované AI",
"Chytré párování kandidátů a pracovních míst",
"Snížení zaujatosti při náboru",
"Personalizovaný onboarding",
],
style="3D izometrická ilustrace, modré a fialové tóny",
output_dir="."
)
Popis obrázku pro jeho odlišnou regeneraci
Jak získat zimní verzi letní krajiny, když máš pouze soubor, žádnou masku a žádné editační nástroje? Jdi přes jazyk. Vize modelu obrázek analyzuje a vytvoří popis dostatečně přesný na to, aby sloužil jako rekonstrukční prompt – námět, kompozice, osvětlení, barvy, styl, perspektiva, nálada. K tomuto popisu poté připojíš svou instrukci pro úpravu. Generační model obdrží kompletní textový prompt, kde se změnila pouze roční doba, a ty získáš obrázek koherentní s originálem, nikoliv něco nesouvisejícího. Je to také nejspolehlivější způsob, jak reprodukovat vizuální identitu referenčního obrázku, který nemůžeš přímo editovat.
from openai import OpenAI
import base64
client = OpenAI()
def analyze_and_vary(image_path: str, instruction: str, output: str):
"""
1. Analyzuje obrázek pomocí GPT Vision
2. Vygeneruje variantu na základě analýzy
"""
# Krok 1: Analýza obrázku
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": (
"Popis tento obrázek podrobně tak, aby ho model "
"pro generování obrázků mohl věrně reprodukovat. "
"Zahrň: námět, kompozici, osvětlení, barvy, styl, "
"perspektivu, náladu. Buď velmi přesný."
)
},
{
"type": "image_url",
"image_url": {
"url": f"data:image/png;base64,{image_b64}"
}
}
]
}
]
)
description = analysis.choices[0].message.content
print(f"Analýza: {description[:150]}...")
# Krok 2: Generování upravené varianty
variant_prompt = f"{description}. Požadovaná úprava: {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"Varianta vygenerována: {output}")
analyze_and_vary(
"original_landscape.png",
"Změň roční dobu z léta na zimu, se sněhem na střechách a stromech",
"winter_landscape.png"
)
Zpracování velkých objemů v dávkách
Generování pěti produktových vizuálů v sérii trvá minuty; generování pěti set sekvenčně zabere celou noc a zastaví se při prvním výpadku sítě. Níže uvedené nastavení řeší oba problémy. Každý úkol je samostatný slovník nesoucí své ID, prompt, výstupní soubor a nastavení. Funkce worker obalí volání do bloku try, který vrací stav místo toho, aby shodil celou dávku: zamítnuté generování tak nesrazí ostatních čtyři sta devadesát devět. ThreadPoolExecutor následně paralelizuje provádění, ale s úmyslně nízkým počtem max_workers – v tomto příkladu tři – protože úzkým hrdlem není tvůj stroj, ale kvóty API. Závěrečná zpráva spočítá úspěchy a chyby, abys věděl, co zopakovat.
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:
"""Vygeneruje jeden obrázek z úkolu."""
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):
"""Provede dávku generování s řízenou paralelizací."""
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']}")
# Zpráva
ok = sum(1 for r in results if r["status"] == "ok")
errors = sum(1 for r in results if r["status"] == "error")
print(f"\nDokončeno: {ok} v pořádku, {errors} chyb z {len(tasks)} úkolů")
return results
# Definice dávky úkolů
tasks = [
{
"id": f"product_{i}",
"prompt": f"Fotografie produktu pro e-shop: {product}, bílé pozadí, studio",
"output": f"batch_product_{i}.png",
"quality": "high"
}
for i, product in enumerate([
"hodinky z růžového zlata",
"sluneční brýle aviator",
"pletený kožený náramek",
"prsten s diamantem solitér",
"náhrdelník z kultivovaných perel",
])
]
results = batch_generation(tasks, max_parallel=3)
Přímé publikování do úložiště
Zapisování PNG na disk stroje, na kterém běží skript, dává smysl pouze ve vývoji. V produkci musí obrázek skončit tam, odkud si ho tvůj web stáhne, a zacházka přes lokální souborový systém se stává zbytečným bodem selhání. Formát b64_json se pro toto odstranění hodí: dekódované bajty jsou zabaleny do objektu BytesIO a přímo odeslány do bucketu s explicitním ContentType – bez něj by prohlížeče nabízely stažení místo zobrazení obrázku. Funkce vrací veřejnou URL, což je přesně to, co tvůj CMS potřebuje.
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):
"""Vygeneruje obrázek a přímo jej nahraje na 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"Obrázek uložen na S3: {url}")
return url
# Příklad
url = generate_and_store_s3(
"Ikona mobilní aplikace: otevřená kniha s hvězdami, plochý design",
"my-image-bucket",
"generated/app_icon_v1.png"
)
Co udržuje pipeline v chodu
Pět pipeline v této lekci sdílí stejnou hygienu konstrukce. Každý krok dělá jednu věc, což ti umožňuje nahradit psaní promptů nebo úložiště, aniž bys musel sahat na zbytek. Každý krok si ošetřuje vlastní chyby; jinak by odmítnutí moderací uprostřed dávky shodilo celý řetězec – přesně tomu zabraňuje try ve funkci generate_one_image. Paralelismus zůstává tlumen, aby respektoval limity rychlosti, a v tomto bodě stojí opatrnost méně než obnova po dočasném zákazu.
Zůstávají dva méně viditelné, ale stejně rozhodující návyky. Loguj skutečně odeslané prompty, zejména když jsou psány jazykovým modelem: bez tohoto logu se obrázek, který máš rád, stane při druhém spuštění nereprodukovatelným. A cacheuj výsledky, kdykoliv se může vrátit stejný prompt, což příští lekce formalizuje do kompletního systému.
Nyní sestav svůj vlastní úplný řetězec: jako vstup bere název článku, požádá jazykový model o tři popisy relevantních vizuálů, paralelně vygeneruje tři obrázky a vytvoří souhrnné JSON propojující každý prompt s jeho souborem. Budeš pak mít vše potřebné k ilustrování celého blogu bez manuálního zásahu.