Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Kombinace generování obrázků s dalšími nástroji API

Lekce 10 z 12 Aktualizováno 2. listopadu 2026 Vývojář
Na této stránce
  1. Kombinace generování obrázků s dalšími nástroji API
  2. Nech jazykový model napsat prompt
  3. Ilustrace článku od začátku do konce
  4. Popis obrázku pro jeho odlišnou regeneraci
  5. Zpracování velkých objemů v dávkách
  6. Přímé publikování do úložiště
  7. Co udržuje pipeline v chodu

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. Modely gpt-image-1.5, gpt-image-1-mini a chatgpt-image-latest budou 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-flare je rychlejší pro standardní generování. Obě modely také podporují nastavení kvality xhigh a max. Modely GPT Image vždy vracejí obrázky v base64: parametr response_format ze 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.