Kombinovanie generovania obrázkov s ďalšími nástrojmi API
Na tejto strane
Aktualizácia 2. novembra 2026 — Modely obrázkov. Model
gpt-image-1, pre ktorý bol tento kurz pôvodne napísaný, bol ukončený 23. októbra 2026. Modelygpt-image-1.5,gpt-image-1-miniachatgpt-image-latestbudú vyradené 1. decembra 2026. Príklady teraz využívajúgpt-image-2.5-sunburst, ktorý ponúka najvyššiu presnosť pri úpravách;gpt-image-2.5-flareje rýchlejší pri štandardnom generovaní. Oba modely tiež podporujú nastavenia kvalityxhighamax. Modely GPT Image vždy vracajú obrázky v base64: parameterresponse_formatzo starších modelov DALL·E nie je podporovaný a bol z kódu odstránený. Zdroj: Image generation (OpenAI).
Kombinovanie generovania obrázkov s ďalšími nástrojmi API
Samotné generovanie obrázkov je remeselný nástroj: napíšeš prompt a dostaneš súbor. Jeho skutočná sila sa prejaví, keď sa stane jedným článkom v automatizovanom reťazci – jazykový model, ktorý napíše prompt, vizuálna analýza, ktorá popíše referenčný obrázok, alebo úložisko, ktoré výsledok zverejní. Táto lekcia ti ukáže, ako tieto časti prepojiť.
Nechaj jazykový model napísať prompt
Tvoji používatelia alebo kolegovia nepíšu vizuálne prompty; píšu zadania. „Potrebujem obrázok pre článok o AI v zdravotníctve, futuristický, no ľudský“ neobsahuje žiadnu kompozíciu, osvetlenie ani paletu. Namiesto toho, aby si ich nútil učiť sa slovník z predchádzajúcej lekcie, vlož do procesu jazykový model, ktorý sa postará o preklad. Priraď mu v systémovej správe rolu art direktora a požaduj, aby vyprodukoval konkrétne vrstvy promptu s prísnym pokynom, aby nevytvoril nič iné. Inak dostaneš zdvorilé vysvetlenie, ktoré by si následne musel poslať modelu GPT Image.
from openai import OpenAI
import base64
client = OpenAI()
def text_to_image(brief: str, output: str):
"""
Dvojkrokový pipeline:
1. LLM vygeneruje optimálny vizuálny prompt
2. GPT Image vytvorí obrázok
"""
# Krok 1: Vygenerovanie vizuálneho promptu pomocou 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]}...")
# Krok 2: Generovanie obrázka
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"
)
Ilustrovanie článku od začiatku do konca
Fejtón potrebuje úvodný obrázok a jednu ilustráciu na každú sekciu. Tieto obrázky musia pôsobiť súdržne, no nesmú byť totožné. Funkcia illustrate_article aplikuje túto logiku tým, že do každého promptu znovu vkladá štýl a zakaždým opakuje názov článku, čím celej sade dodáva tematickú jednotu. Dva detaily šetriace náklady si zaslúžia pozornosť: úvodný obrázok sa generuje v kvalite high, pretože ho vidí každý a často sa zdieľa, zatiaľ čo ilustrácie sekcií zostávajú v kvalite medium, keďže sa zobrazujú menšie a nižšie na stránke. Pri piatich sekciách v tomto príklade o AI v náboroch tento kompromis zreže účet, pričom čitateľ si nič nevšimne.
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ú ilustráciu + jednu pre každú sekciu.
"""
results = []
# Úvodný obrázok
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}")
# Ilustrácie sekcií
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="."
)
Popis obrázka na jeho následnú inú regeneráciu
Ako získaš zimnú verziu letnej krajiny, keď máš k dispozícii len súbor, žiadnu masku a žiadne editačné nástroje? Cez jazyk. Vízny model analyzuje obrázok a vytvorí dostatočne presný popis, ktorý poslúži ako prompt na rekonštrukciu – predmet, kompozícia, osvetlenie, farby, štýl, perspektíva, nálada. K tomuto popisu následne pripojíš svoju inštrukciu na úpravu. Model na generovanie dostane kompletný textový prompt, v ktorom sa zmenilo len ročné obdobie, a ty získaš obrázok konzistentný s originálom, namiesto niečoho nesúvisiaceho. Toto je tiež najspoľahlivejší spôsob, ako reprodukovať vizuálnu identitu referenčného obrázka, ktorý nemôžeš priamo editovať.
from openai import OpenAI
import base64
client = OpenAI()
def analyze_and_vary(image_path: str, instruction: str, output: str):
"""
1. Analyzuje obrázok pomocou GPT Vision
2. Vygeneruje variant na základe analýzy
"""
# Krok 1: Analýza obrázka
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]}...")
# Krok 2: Generovanie upraveného variantu
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"
)
Spracovanie veľkých objemov v dávkach
Generovanie piatich produktových vizuálov za sebou trvá minúty; generovanie päťsto sekvenčne zaberie celú noc a zastaví sa pri prvom výpadku siete. Nižšie uvedené nastavenie rieši oba problémy. Každá úloha je samostatný slovník nesúci svoje ID, prompt, výstupný súbor a nastavenia. Funkcia worker obalí volanie do bloku try, ktorý vráti status namiesto toho, aby zhodil celú dávku: zamietnuté generovanie už nezrazí ostatných štyristo deväťdesiatdeväť. ThreadPoolExecutor následne paralelizuje vykonávanie, ale s úmyselne nízkym počtom max_workers – v tomto príklade tri – pretože úzkym hrdlom nie je tvoj stroj, ale kvóty API. Záverečná správa spočíta úspechy a chyby, aby si vedel, čo treba zopakovať.
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:
"""Generuje jeden obrázok z úlohy."""
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):
"""Vykoná dávku generovaní s kontrolovanou paralelizáciou."""
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']}")
# Sprá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"\nFinished: {ok} ok, {errors} errors out of {len(tasks)} tasks")
return results
# Definícia dávky úloh
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)
Priame publikovanie do úložiska
Zapisovanie PNG na disk stroja, na ktorom beží skript, má zmysel len vo vývoji. V produkcii musí obrázok skončiť tam, odkiaľ ho bude tvoja stránka sťahovať, a obchádzanie cez lokálny súborový systém sa stáva zbytočným bodom zlyhania. Formát b64_json sa na toto odstránenie hodí: dekódované bajty sa zabalia do objektu BytesIO a pošlú priamo do bucketu s explicitným ContentType – bez neho by prehliadače namiesto zobrazenia obrázka ponúkli stiahnutie. Funkcia vráti verejnú URL, čo je presne to, čo tvoj CMS 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):
"""Generuje obrázok a nahra ho priamo 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"Image stored on S3: {url}")
return url
# Príklad
url = generate_and_store_s3(
"Mobile app icon: open book with stars, flat design",
"my-image-bucket",
"generated/app_icon_v1.png"
)
Čo udržiava pipeline funkčné
Päť pipelineov v tejto lekcii zdieľa rovnakú hygienu konštrukcie. Každý krok robí jednu vec, čo ti umožňuje nahradiť písanie promptov alebo úložisko bez dotyku so zvyškom. Každý krok si ošetruje vlastné chyby; inak by zamietnutie moderáciou uprostred dávky zrazilo celý reťazec – presne tomu zabraňuje try vo funkcii generate_one_image. Paralelizmus zostáva tlmený, aby sa rešpektovali limity rýchlosti, a v tomto bode stojí opatrnosť menej než obnova po dočasnom zákaze.
Zostávajú dva menej viditeľné, no rovnako rozhodujúce návyky. Loguj skutočne odoslané prompty, najmä keď ich píše jazykový model: bez tohto logu sa obrázok, ktorý sa ti páči, stane pri druhom spustení nereprodukovateľným. A cacheuj výsledky vždy, keď sa môže vrátiť rovnaký prompt, čo nasledujúca lekcia formalizuje do kompletného systému.
Teraz poskladaj svoj vlastný úplný reťazec: ako vstup vezme názov článku, požiada jazykový model o tri popisy relevantných vizuálov, vygeneruje tri obrázky paralelne a vytvorí súhrnné JSON spájajúce každý prompt s jeho súborom. Potom budeš mať všetko potrebné na ilustrovanie celého blogu bez manuálneho zásahu.