Optimalizace nákladů
Na této stránce
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. 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í úrovně kvalityxhighamax. Modely GPT Image vždy vracejí obrázky v base64: parametrresponse_formatze 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.
| Faktor | Dopad 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.
| Strategie | Odhadované ú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.