Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Optimalizácia nákladov

Lekcia 11 z 12 Aktualizované 2. novembra 2026 Vývojár
Na tejto strane
  1. Optimalizácia nákladov
  2. Pochopte štruktúru nákladov
  3. Prototypuj v nízkej kvalite, doručuj vo vysokej
  4. Nikdy neplať dvakrát za ten istý obrázok
  5. Veľkosť presne podľa potreby
  6. Upravuj namiesto regenerovania
  7. Vieš, kam idú peniaze
  8. Kde začať

Aktualizované 2. novembra 2026 — Modely na generovanie obrázkov. Model gpt-image-1, pre ktorý bol tento kurz pôvodne napísaný, bol ukončený 23. októbra 2026. Modely gpt-image-1.5, gpt-image-1-mini a chatgpt-image-latest budú 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-flare je rýchlejší pri štandardnom generovaní. Oba modely tiež podporujú úrovne kvality xhigh a max. Modely GPT Image vždy vracajú obrázky v base64: parameter response_format zo starších modelov DALL·E sa už neprijíma a bol z kódu odstránený. Zdroj: Generovanie obrázkov (OpenAI).

Optimalizácia nákladov

V produkcii sa generovanie obrázkov prestáva byť technickou kuriozitou a stáva sa rozpočtovou položkou. Každý tím, ktorý mesačne vyprodukuje niekoľko stoviek vizuálov, si to rýchlo všimne. Prvou reakciou – obmedzenie využívania – je zároveň tá najmenej múdra. Táto lekcia pokrýva päť stratégií, ktoré znižujú výdavky bez kompromisov v kvalite vašich výstupov, pretože cielia na to, čo vyhadzujete, nie na to, čo si nechávate.

Pochopte štruktúru nákladov

Náklady na generovanie závisia od troch faktorov.

FaktorVplyv na náklady
Kvalita (low, medium, high)Priamy násobiteľ
Rozlíšenie (1024, 1536)Väčšie = drahšie
Počet obrázkov (n)Lineárne náklady (n × jednotková cena)

Tieto tri faktory sa navzájom násobia, čo vysvetľuje, prečo nedisciplinované experimentovanie stojí o rád viac než to isté experimentovanie vykonávané s disciplínou. Nasledujúci skript vypisuje päť kombinácií, s ktorými sa v produkcii stretneš najčastejšie. Hoci presné sumy nájdeš na svojom dashboarde OpenAI, poradie riadkov už samo o sebe ukazuje rozsah kompromisov.

from openai import OpenAI

client = OpenAI()

# Porovnanie nákladov: rovnaký prompt, rôzne parametre
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("Konfigurácia            | Využitie (odhad)")
print("-" * 50)
for config in configs:
    print(f"{config['label']:22s} | Skontroluj svoj OpenAI dashboard")

Prototypuj v nízkej kvalite, doručuj vo vysokej

Toto je zďaleka najnákladovo efektívnejšia stratégia a zároveň najjednoduchšia na adopciu. Počas fázy experimentovania neposudzuješ jemnosť prechodov: posudzuješ kompozíciu, rámovanie a celkovú náladu, čo je všetko dokonale viditeľné aj pri quality: low. Prepnutie na high dáva zmysel až pre obrázok, ktorý skutočne zamýšľaš publikovať. Nižšie uvedený workflow túto sekvenciu formalizuje vytvorením piatich úsporných konceptov nasledovaných jediným finálnym renderom, s pridanou výhodou prepnutia na formát na šírku (1536×1024) pre definitívnu verziu. Pri piatich pokusoch a jednom doručení sa úspory uvedené na konci skriptu pohybujú okolo 60 % v porovnaní s experimentovaním vykonávaným výlučne v high.

from openai import OpenAI
import base64

client = OpenAI()

def economical_workflow(prompt: str, output: str, n_drafts: int = 5):
    """
    Dvojfázový workflow:
    1. Rýchle koncepty v nízkej kvalite
    2. Finálny render vo vysokej kvalite
    """
    # Fáza 1: Rýchle experimentovanie
    print("Fáza 1: rýchle koncepty (nízka 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"  Koncept {i+1}: {path}")

    # Fáza 2: Finálny render (po ľudskom výbere najlepšieho konceptu)
    print("\nFáza 2: finálny render (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álny render: {output}")

    # Zhrnutie: 5 nízkych + 1 vysoký namiesto 5 vysokých
    print(f"\nZhrnutie: {n_drafts} nízkych konceptov + 1 finálny vysoký")
    print("Odhadované úspory: ~60 % v porovnaní s úplne vysokým experimentovaním")


economical_workflow(
    "Ilustrácia kampusu zelenej technológie so solárnymi panelmi, architektonický štýl",
    "campus_final.png"
)

Nikdy neplať dvakrát za ten istý obrázok

V reálnej aplikácii sa ten istý prompt vracia oveľa častejšie, než by si čakal: používateľ obnoví stránku, skript zostavenia znovu spustí generovanie alebo sa ikona použije na troch rôznych stránkach. Každý z týchto prípadov predstavuje zbytočný poplatok. Nižšie uvedená cache ich eliminuje výpočtom hashu SHA-256 z trojice (prompt, veľkosť, kvalita) – troch prvkov, ktoré určujú fakturovaný výsledok – a skrátí tento hash na šestnásť znakov, aby vytvoril spravovateľný názov súboru. Všimni si kontrolu os.path.exists: index môže poznať záznam, ktorého súbor bol z disku vymazaný; v takom prípade kód obrázok znovu vygeneruje, namiesto toho aby vrátil neplatnú 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číta 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ázok alebo vráti výsledok z cache."""
    # Vytvorenie unikátneho kľúča na základe parametrov
    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šala, regenerujem...")

    # Nie je 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"Vygenerované a uložené do cache: {path}")
    return path


# Prvé generovanie: volanie API
path1 = generate_with_cache("Minimalistické logo pre technologický startup, modrá a biela")
# Druhé identické volanie: obslúžené z cache
path2 = generate_with_cache("Minimalistické logo pre technologický startup, modrá a biela")

Veľkosť presne podľa potreby

Generovanie vysoko rozlíšenej miniatúry, ktorá sa bude zobrazovať v štvorci s veľkosťou 80 pixelov, je ako platiť za výstavnú tlač len preto, aby si ju strčil do peňaženky. Liekom je prestať nechávať toto rozhodnutie na rozmar vývojára a namiesto toho ho odvodiť od deklarovaného použitia. Slovník generate_for_usage rozdeľuje prípady do troch rodín: malé webové formáty – miniatúry a avatary – ktoré si vystačia s low; štandardné webové použitie – hlavičky blogov, príspevky na sociálne siete – ktoré si vyžadujú medium; a médiá, kde záleží na detailoch – hero bannery, tlač A4, portfóliá – ktoré ospravedlňujú high. Posledné dve volania ilustrujú rozdiel: ten istý mačací astronaut stojí násobne viac podľa toho, či skončí ako miniatúra alebo ako banner na domovskej stránke.

from openai import OpenAI
import base64

client = OpenAI()

def generate_for_usage(prompt: str, usage: str, output: str):
    """Automaticky vyberie optimálne rozlíšenie a kvalitu."""
    configs = {
        # Malé webové použitie
        "thumbnail": {"size": "1024x1024", "quality": "low"},
        "avatar": {"size": "1024x1024", "quality": "low"},

        # Štandardné webové použitie
        "blog_header": {"size": "1536x1024", "quality": "medium"},
        "social_post": {"size": "1024x1024", "quality": "medium"},

        # Použitie vo vysokej kvalite
        "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žitie {usage} ({config['quality']}/{config['size']}) → {output}")


generate_for_usage("Roztomilá mačka v astronautickom obleku", "thumbnail", "cat_thumb.png")
generate_for_usage("Roztomilá mačka v astronautickom obleku", "hero_banner", "cat_hero.png")

Upravuj namiesto regenerovania

Klient schváli fotku, ale chce iné nebo. Prirodzený reflex – znovu spustiť celé generovanie s upraveným promptom – ťa pripraví o peniaze za celý obrázok a, čo je horšie, stratíš zvyšok kompozície, ktorú všetci schválili. Funkcia images.edit() rieši túto situáciu za cenu jednej úpravy: funkcia edit_detail zostaví masku, ktorá uvoľní len relevantný obdĺžnik, tu horných 300 pixelov výšky zodpovedajúcich nebu, a prompt opisuje len obsah tohto pruhu. Samotná krajina sa neposunie ani o pixel.

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

client = OpenAI()

# Namiesto regenerovania celého obrázka kvôli zmene detailu
# uprav len relevantnú oblasť.

def edit_detail(image_path: str, zone: tuple, new_content: str, output: str):
    """
    Upraví detail v existujúcom obrázku.
    zone: (x1, y1, x2, y2) oblasti na úpravu
    """
    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 namiesto 1 plného generovania")


# Príklad: zmena len neba na fotografii
edit_detail(
    "landscape.png",
    (0, 0, 1024, 300),
    "Modrá obloha s niekoľkými nadýchanými bielymi oblakmi",
    "landscape_sky_edited.png"
)

Vieš, kam idú peniaze

Štyri predchádzajúce stratégie predpokladajú, že vieš, čo spotrebúvaš, a táto viditeľnosť neprichádza automaticky: dashboard poskytovateľa ti dá súčet, nie rozpis podľa projektu alebo kvality. Lokálny log túto medzeru vyplní za zanedbateľné náklady na vývoj. log_generation pridá časovo označený riadok pre každé volanie, pričom skráti prompt na 100 znakov, aby zostal čitateľný, a usage_report následne všetko agreguje podľa úrovne kvality. Tento rozpis spúšťa rozhodovania: ak tvoj log odhalí, že 80 % tvojich obrázkov je generovaných v high, zatiaľ čo väčšina končí na sociálnych sieťach, práve si našiel svoj 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é generovanie na sledovanie nákladov."""
    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 o spotrebe."""
    if not os.path.exists(USAGE_FILE):
        print("Žiadne údaje o spotrebe.")
        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 generovaní: {total}")
    print(f"Rozpis podľa kvality:")
    for q, count in sorted(by_quality.items()):
        print(f"  {q}: {count} obrázkov")


usage_report()

Kde začať

Nie všetky tieto stratégie ponúkajú rovnaký návratnosť úsilia a nasledujúca tabuľka ti pomôže stanoviť priority.

StratégiaOdhadované úsporyÚsilie
Nízka kvalita pre prototypovanie50 – 70 %Minimálne
Cache promptov10 – 30 % (ak sa opakujú)Stredné
Prispôsobené rozlíšenie20 – 40 %Minimálne
Úprava vs. regenerovanie30 – 50 % (na úpravu)Stredné
Sledovanie výdavkovNepriame (viditeľnosť)Stredné

Dva riadky jasne vynikajú: prototypovanie v low a prispôsobenie rozlíšenia použitiu vyžadujú minimálne úsilie za polovicu možných úspor. Začni týmito dvoma a potom pridaj cache a cielené úpravy, keď to tvoj objem opodstatní. Samo sledovanie výdavkov nič priamo neušetrí – ale práve ono ti povie, ktorá zo zvyšných štyroch stratégií prináša vo tvojom konkrétnom kontexte ovocie.

Najlepší spôsob, ako prestať nad tým premýšľať, je zapuzdriť tieto pravidlá do jediného kontrolného bodu. Napíš wrapper okolo client.images.generate(), ktorý integruje cache promptov, automatické prispôsobenie kvality a rozlíšenia na základe deklarovaného použitia a logovanie každého volania; potom ho spusti na desiatich generovaniach a prečítaj si report o spotrebe. Od tohto momentu celý tvoj tím šetrí peniaze bez toho, aby si musel niečo pamätať.