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

Optimalizace nákladů

Lekce 11 z 12 Aktualizováno 2. listopadu 2026 Vývojář
Na této stránce
  1. Optimalizace nákladů
  2. Pochopte strukturu nákladů
  3. Prototypuj v nízké kvalitě, dodávej ve vysoké
  4. Nikdy neplať dvakrát za stejný obrázek
  5. Přesně nastav velikost
  6. Upravuj místo regenerování
  7. Věz, kam peníze jdou
  8. Kde začít

Aktualizováno 2. listopadu 2026 — Modely pro generování 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í úrovně kvality xhigh a max. Modely GPT Image vždy vracejí obrázky v base64: parametr response_format ze starších modelů DALL·E již není přijímán a byl z kódu odstraněn. Zdroj: Generování obrázků (OpenAI).

Optimalizace nákladů

V produkci přestává být generování obrázků technickou kuriozitou a stává se běžnou položkou rozpočtu. Každý tým, který měsíčně vytvoří několik stovek vizuálů, si toho rychle všimne. První reakcí bývá omezit využívání, což je však ta nejméně chytrá možnost. Tato lekce pokrývá pět strategií, které snižují výdaje bez kompromisů v kvalitě vašich výstupů, protože cílí na to, co zahazujete, nikoliv na to, co si ponecháte.

Pochopte strukturu nákladů

Náklady na generování závisí na třech faktorech.

FaktorDopad na náklady
Kvalita (low, medium, high)Přímý násobitel
Rozlišení (1024, 1536)Větší = dražší
Počet obrázků (n)Lineární náklady (n × jednotková cena)

Tyto tři faktory se vzájemně násobí, což vysvětluje, proč nedisciplinované experimentování stojí řádově více než stejné experimentování prováděné s disciplínou. Níže uvedený skript vypisuje pět kombinací, se kterými se v produkci setkáte nejčastěji. Přesné částky sice uvidíte na svém dashboardu OpenAI, ale pořadí řádků již samo o sobě ukazuje rozsah kompromisů.

from openai import OpenAI

client = OpenAI()

# Porovnání nákladů: stejný prompt, různé parametry
configs = [
    {"quality": "low", "size": "1024x1024", "label": "Low / 1024"},
    {"quality": "medium", "size": "1024x1024", "label": "Medium / 1024"},
    {"quality": "high", "size": "1024x1024", "label": "High / 1024"},
    {"quality": "medium", "size": "1536x1024", "label": "Medium / 1536"},
    {"quality": "high", "size": "1536x1024", "label": "High / 1536"},
]

print("Konfigurace            | Využití (odhad)")
print("-" * 50)
for config in configs:
    print(f"{config['label']:22s} | Zkontrolujte svůj dashboard OpenAI")

Prototypuj v nízké kvalitě, dodávej ve vysoké

Toto je zdaleka nejefektivnější strategie z hlediska nákladů a zároveň nejjednodušší na adopci. Během fáze experimentování neposuzujete jemnost přechodů barev: posuzujete kompozici, rámování a celkovou náladu, což je vše perfektně viditelné při quality: low. Přepnutí na high dává smysl až pro obrázek, který skutečně zamýšlíte publikovat. Níže uvedený workflow tuto sekvenci formalizuje vytvořením pěti úsporných návrhů následovaných jediným finálním vykreslením, s přidanou výhodou přepnutí do formátu na šířku (1536×1024) pro definitivní verzi. Při pěti pokusech a jedné dodávce se úspory uvedené na konci skriptu pohybují kolem 60 % ve srovnání s experimentováním prováděným výhradně v high.

from openai import OpenAI
import base64

client = OpenAI()

def economical_workflow(prompt: str, output: str, n_drafts: int = 5):
    """
    Dvoufázový workflow:
    1. Rychlé návrhy v nízké kvalitě
    2. Finální vykreslení ve vysoké kvalitě
    """
    # Fáze 1: Rychlé experimentování
    print("Fáze 1: rychlé návrhy (nízká kvalita)")
    drafts = []
    for i in range(n_drafts):
        response = client.images.generate(
            model="gpt-image-2.5-sunburst",
            prompt=prompt,
            size="1024x1024",
            quality="low",
        )

        path = f"draft_{i+1}.png"
        data = base64.b64decode(response.data[0].b64_json)
        with open(path, "wb") as f:
            f.write(data)
        drafts.append(path)
        print(f"  Návrh {i+1}: {path}")

    # Fáze 2: Finální vykreslení (po lidském výběru nejlepšího návrhu)
    print("\nFáze 2: finální vykreslení (vysoká kvalita)")
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=prompt,
        size="1536x1024",
        quality="high",
    )

    data = base64.b64decode(response.data[0].b64_json)
    with open(output, "wb") as f:
        f.write(data)
    print(f"  Finální vykreslení: {output}")

    # Shrnutí: 5 nízkých + 1 vysoký místo 5 vysokých
    print(f"\nShrnutí: {n_drafts} nízkých návrhů + 1 finální vysoký")
    print("Odhadované úspory: ~60 % oproti experimentování pouze ve vysoké kvalitě")


economical_workflow(
    "Ilustrare zeleného technologického kampusu se solárními panely, architektonický styl",
    "campus_final.png"
)

Nikdy neplať dvakrát za stejný obrázek

V reálné aplikaci se stejný prompt vrací mnohem častěji, než bys čekal: uživatel obnoví stránku, build skript znovu spustí generování nebo se ikona použije na třech různých stránkách. Každý z těchto případů představuje zbytečný poplatek. Níže uvedená cache je eliminuje výpočtem SHA-256 hashe trojice (prompt, size, quality) – tří prvků, které určují fakturovaný výsledek – a zkrácením tohoto hashe na šestnáct znaků pro vytvoření spravovatelného názvu souboru. Všimni si kontroly os.path.exists: index může znát záznam, jehož soubor byl z disku smazán; v takovém případě kód obrázek znovu vygeneruje, místo aby vrátil nefunkční cestu.

import hashlib
import json
import os
from openai import OpenAI
import base64

client = OpenAI()

CACHE_DIR = "image_cache"
CACHE_INDEX = os.path.join(CACHE_DIR, "index.json")

def load_cache() -> dict:
    """Načte index cache."""
    if os.path.exists(CACHE_INDEX):
        with open(CACHE_INDEX, "r") as f:
            return json.load(f)
    return {}

def save_cache(cache: dict):
    """Uloží index cache."""
    os.makedirs(CACHE_DIR, exist_ok=True)
    with open(CACHE_INDEX, "w") as f:
        json.dump(cache, f, indent=2, ensure_ascii=False)

def generate_with_cache(
    prompt: str,
    size: str = "1024x1024",
    quality: str = "medium"
) -> str:
    """Vygeneruje obrázek nebo vrátí výsledek z cache."""
    # Vytvoření unikátního klíče na základě parametrů
    key_data = f"{prompt}|{size}|{quality}"
    cache_key = hashlib.sha256(key_data.encode()).hexdigest()[:16]

    cache = load_cache()

    if cache_key in cache:
        cached_path = cache[cache_key]["path"]
        if os.path.exists(cached_path):
            print(f"Zásah cache: {cached_path}")
            return cached_path
        else:
            print("Cache vypršela, regeneruji...")

    # Není v cache: generuj
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=prompt,
        size=size,
        quality=quality,
    )

    path = os.path.join(CACHE_DIR, f"{cache_key}.png")
    os.makedirs(CACHE_DIR, exist_ok=True)
    data = base64.b64decode(response.data[0].b64_json)
    with open(path, "wb") as f:
        f.write(data)

    cache[cache_key] = {
        "prompt": prompt[:100],
        "size": size,
        "quality": quality,
        "path": path
    }
    save_cache(cache)

    print(f"Vygenerováno a uloženo do cache: {path}")
    return path


# První generování: volání API
path1 = generate_with_cache("Minimalistické logo pro technologický startup, modrá a bílá")
# Druhé identické volání: obslouženo z cache
path2 = generate_with_cache("Minimalistické logo pro technologický startup, modrá a bílá")

Přesně nastav velikost

Generování náhledu ve vysokém rozlišení, který bude zobrazen v čtverci o velikosti 80 pixelů, je jako platit za výstavní tisk jen proto, abys ho strčil do peněženky. Řešením je přestat nechávat toto rozhodnutí na libovůli vývojáře a místo toho jej odvodit od deklarovaného použití. Slovník generate_for_usage rozděluje případy do tří rodin: malé webové formáty – náhledy a avatary – kterým stačí low; standardní webové použití – záhlaví blogů, příspěvky na sociální sítě – které vyžadují medium; a média, kde na jemnosti skutečně záleží – hlavní bannery, tisk A4, portfolia – která ospravedlňují high. Poslední dvě volání ilustrují rozdíl: stejná kočka v astronautickém obleku stojí násobně více v závislosti na tom, zda skončí jako náhled nebo jako banner na domovské stránce.

from openai import OpenAI
import base64

client = OpenAI()

def generate_for_usage(prompt: str, usage: str, output: str):
    """Automaticky zvolí optimální rozlišení a kvalitu."""
    configs = {
        # Malé webové použití
        "thumbnail": {"size": "1024x1024", "quality": "low"},
        "avatar": {"size": "1024x1024", "quality": "low"},

        # Standardní webové použití
        "blog_header": {"size": "1536x1024", "quality": "medium"},
        "social_post": {"size": "1024x1024", "quality": "medium"},

        # Použití ve vysoké kvalitě
        "hero_banner": {"size": "1536x1024", "quality": "high"},
        "print_a4": {"size": "1024x1536", "quality": "high"},
        "portfolio": {"size": "1024x1024", "quality": "high"},
    }

    config = configs.get(usage, {"size": "1024x1024", "quality": "medium"})

    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=prompt,
        size=config["size"],
        quality=config["quality"],
    )

    data = base64.b64decode(response.data[0].b64_json)
    with open(output, "wb") as f:
        f.write(data)
    print(f"Použití {usage} ({config['quality']}/{config['size']}) → {output}")


generate_for_usage("Roztomilá kočka v astronautickém obleku", "thumbnail", "cat_thumb.png")
generate_for_usage("Roztomilá kočka v astronautickém obleku", "hero_banner", "cat_hero.png")

Upravuj místo regenerování

Klient schválí fotografii, ale chce jiné nebe. Přirozeným reflexem je znovu spustit celé generování s upraveným promptem, což tě stojí peníze za celý obrázek a co hůř, přicházíš o zbytek kompozice, kterou všichni schválili. Funkce images.edit() tuto situaci řeší za cenu jedné úpravy: funkce edit_detail vytvoří masku, která uvolní pouze příslušný obdélník, zde horních 300 pixelů na výšku odpovídajících nebi, a prompt popisuje pouze obsah tohoto pruhu. Samotná krajina se neposune ani o pixel.

import base64
from openai import OpenAI
from PIL import Image, ImageDraw

client = OpenAI()

# Místo regenerování celého obrázku pro změnu detailu
# uprav pouze příslušnou oblast.

def edit_detail(image_path: str, zone: tuple, new_content: str, output: str):
    """
    Upraví detail v existujícím obrázku.
    zone: (x1, y1, x2, y2) oblasti k úpravě
    """
    source = Image.open(image_path)
    mask = Image.new("RGBA", source.size, (0, 0, 0, 255))
    draw = ImageDraw.Draw(mask)
    draw.rectangle(zone, fill=(0, 0, 0, 0))
    mask.save("temp_mask.png")

    response = client.images.edit(
        model="gpt-image-2.5-sunburst",
        image=open(image_path, "rb"),
        mask=open("temp_mask.png", "rb"),
        prompt=new_content
    )

    with open(output, "wb") as f:
        f.write(base64.b64decode(response.data[0].b64_json))
    print(f"Detail upraven: {output}")
    print("Náklady: 1 úprava místo 1 plného generování")


# Příklad: změna pouze nebe na fotografii
edit_detail(
    "landscape.png",
    (0, 0, 1024, 300),
    "Modrá obloha s několika nadýchanými bílými mraky",
    "landscape_sky_edited.png"
)

Věz, kam peníze jdou

Čtyři předchozí strategie předpokládají, že víš, co spotřebováváš, a tato viditelnost nepřichází automaticky: dashboard poskytovatele ti dá součet, nikoliv rozpis podle projektu nebo kvality. Místní log tuto mezeru vyplní za zanedbatelné náklady na vývoj. Funkce log_generation přidá časové razítko pro každé volání a zkrátí prompt na 100 znaků, aby zůstal čitelný, a usage_report následně vše agreguje podle úrovně kvality. Tento rozpis spouští rozhodování: pokud tvůj log odhalí, že 80 % tvých obrázků je generováno v high, zatímco většina končí na sociálních sítích, právě jsi našel svůj zdroj úspor.

import json
import os
from datetime import datetime

USAGE_FILE = "image_usage_log.json"

def log_generation(prompt: str, size: str, quality: str, n: int = 1):
    """Loguje každé generování pro sledování nákladů."""
    if os.path.exists(USAGE_FILE):
        with open(USAGE_FILE, "r") as f:
            log = json.load(f)
    else:
        log = []

    entry = {
        "timestamp": datetime.now().isoformat(),
        "prompt": prompt[:100],
        "size": size,
        "quality": quality,
        "n_images": n,
    }

    log.append(entry)

    with open(USAGE_FILE, "w") as f:
        json.dump(log, f, indent=2, ensure_ascii=False)


def usage_report():
    """Zobrazí report spotřeby."""
    if not os.path.exists(USAGE_FILE):
        print("Žádná data o spotřebě.")
        return

    with open(USAGE_FILE, "r") as f:
        log = json.load(f)

    total = len(log)
    by_quality = {}
    for entry in log:
        q = entry["quality"]
        by_quality[q] = by_quality.get(q, 0) + entry["n_images"]

    print(f"Celkový počet generování: {total}")
    print(f"Rozpis podle kvality:")
    for q, count in sorted(by_quality.items()):
        print(f"  {q}: {count} obrázků")


usage_report()

Kde začít

Ne všechny tyto strategie nabízejí stejnou návratnost úsilí a následující tabulka ti pomůže stanovit priority.

StrategieOdhadované úsporyÚsilí
Nízká kvalita pro prototypování50–70 %Minimální
Cache promptů10–30 % (pokud se opakují)Střední
Přizpůsobené rozlišení20–40 %Minimální
Úprava vs. regenerování30–50 % (na úpravu)Střední
Sledování výdajůNepřímé (viditelnost)Střední

Dva řádky jasně vynikají: prototypování v low a přizpůsobení rozlišení použití vyžadují minimální úsilí za polovinu možných úspor. Začni těmito, poté přidej caching a cílené úpravy, jakmile to tvůj objem opodstatní. Samo sledování výdajů přímo nic neušetří – ale právě ono ti řekne, která ze zbývajících čtyř strategií ve tvém konkrétním kontextu skutečně přináší ovoce.

Nejlepším způsobem, jak na to přestat myslet, je zapouzdřit tato pravidla do jediného kontrolního bodu. Napiš wrapper kolem client.images.generate(), který integruje cache promptů, automatickou adaptaci kvality a rozlišení na základě deklarovaného použití a logování každého volání; poté jej spusť na deseti generováních a přečti si report spotřeby. Od té chvíle bude celý tvůj tým šetřit peníze, aniž by si musel cokoli pamatovat.