Optimiziraj troškove
Na ovoj stranici
Ažurirano 2. studenoga 2026. — Modeli za slike. Model
gpt-image-1, za koji je ovaj tečaj izvorno napisan, ukinut je 23. listopada 2026.. Modeligpt-image-1.5,gpt-image-1-miniichatgpt-image-latestbit će povučeni iz upotrebe 1. prosinca 2026.. Primjeri sada koristegpt-image-2.5-sunburst, koji nudi najveću preciznost za uređivanje;gpt-image-2.5-flareje brži za standardno generiranje. Oba modela također podržavaju razine kvalitetexhighimax. GPT Image modeli uvijek vraćaju slike u base64 formatu: parametarresponse_formatiz starijih DALL·E modela više se ne prihvaća i uklonjen je iz koda. Izvor: Image generation (OpenAI).
Optimiziraj troškove
U produkcijskom okruženju generiranje slika prestaje biti tehnička zanimljivost i postaje stavka u proračunu. Svaki tim koji mjesečno proizvede nekoliko stotina vizuala to brzo primijeti. Prva reakcija—ograničavanje korištenja—ujedno je i najmanje pametna. Ova lekcija pokriva pet strategija koje smanjuju troškove bez ugrožavanja kvalitete tvojih isporuka, jer ciljaju na ono što odbacuješ, a ne na ono što zadržavaš.
Razumijevanje strukture troškova
Troškovi generiranja ovise o tri faktora.
| Faktor | Utjecaj na trošak |
|---|---|
Kvaliteta (low, medium, high) | Izravni množitelj |
| Rezolucija (1024, 1536) | Veće = skuplje |
Broj slika (n) | Linearni trošak (n × jedinična cijena) |
Ova tri faktora se međusobno množe, što objašnjava zašto nedisciplinirano istraživanje košta red veličine više od istog istraživanja provedenog s disciplinom. Skripta u nastavku navodi pet kombinacija s kojima ćeš se najčešće susresti u produkciji. Iako se točni iznosi pojavljuju na tvojoj OpenAI nadzornoj ploči, redoslijed redaka već pokazuje razmjere kompromisa.
from openai import OpenAI
client = OpenAI()
# Usporedba troškova: isti prompt, različiti parametri
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("Konfiguracija | Potrošnja (procjena)")
print("-" * 50)
for config in configs:
print(f"{config['label']:22s} | Provjeri svoju OpenAI nadzornu ploču")
Prototipiraj u niskoj, isporučuj u visokoj kvaliteti
Ovo je daleko najisplativija strategija i najjednostavnija za usvajanje. Tijekom faze istraživanja ne procjenjuješ finoću gradijenta: procjenjuješ kompoziciju, kadrovanje i opći ugođaj, a sve je to savršeno vidljivo u quality: low. Prelazak na high ima smisla samo za sliku koju zapravo namjeravaš objaviti. Tijek rada u nastavku formalizira ovaj slijed proizvodeći pet ekonomičnih nacrta nakon čega slijedi jedan konačni render, uz dodatnu prednost prelaska na pejzažni format (1536×1024) za konačnu verziju. Kroz pet pokušaja i jednu isporuku, uštede navedene na kraju skripte kreću se oko 60% u usporedbi s istraživanjem provedenim u potpunosti u high.
from openai import OpenAI
import base64
client = OpenAI()
def economical_workflow(prompt: str, output: str, n_drafts: int = 5):
"""
Dvofazni tijek rada:
1. Brzi nacrti u niskoj kvaliteti
2. Konačni render u visokoj kvaliteti
"""
# Faza 1: Brzo istraživanje
print("Faza 1: brzi nacrti (niska kvaliteta)")
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" Nacrt {i+1}: {path}")
# Faza 2: Konačni render (nakon ljudskog odabira najboljeg nacrta)
print("\nFaza 2: konačni render (visoka kvaliteta)")
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" Konačni render: {output}")
# Sažetak: 5 niskih + 1 visoki umjesto 5 visokih
print(f"\nSažetak: {n_drafts} niskih nacrta + 1 konačni visoki")
print("Procijenjene uštede: ~60% u usporedbi s istraživanjem isključivo u visokoj kvaliteti")
economical_workflow(
"Ilustracija zelenog tehnološkog kampusa sa solarnim panelima, arhitektonski stil",
"campus_final.png"
)
Nikada ne plaćaj dvaput za istu sliku
U stvarnoj aplikaciji isti se prompt vraća mnogo češće nego što bi mogao očekivati: korisnik osvježava stranicu, skripta za build ponovno pokreće generiranje ili se ikona koristi na tri stranice. Svaki od ovih slučajeva predstavlja nepotreban trošak. Predmemorija (cache) u nastavku eliminira ih izračunavanjem SHA-256 hash vrijednosti trojke (prompt, size, quality)—tri elementa koja određuju naplaćeni rezultat—i skraćivanjem tog hasha na šesnaest znakova kako bi se stvorilo upravljivo ime datoteke. Obrati pažnju na provjeru os.path.exists: indeks možda zna za unos čija je datoteka izbrisana s diska, u kojem slučaju kod ponovno generira sliku umjesto da vrati mrtvu putanju.
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:
"""Učitava indeks predmemorije."""
if os.path.exists(CACHE_INDEX):
with open(CACHE_INDEX, "r") as f:
return json.load(f)
return {}
def save_cache(cache: dict):
"""Sprema indeks predmemorije."""
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:
"""Generira sliku ili vraća rezultat iz predmemorije."""
# Stvori jedinstveni ključ na temelju parametara
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"Pogodak u predmemoriji: {cached_path}")
return cached_path
else:
print("Predmemorija istekla, ponovno generiranje...")
# Nije u predmemoriji: generiraj
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"Generirano i pohranjeno u predmemoriju: {path}")
return path
# Prvo generiranje: API poziv
path1 = generate_with_cache("Minimalistički logo za tech startup, plavo i bijelo")
# Drugi identičan poziv: posluženo iz predmemorije
path2 = generate_with_cache("Minimalistički logo za tech startup, plavo i bijelo")
Precizno odredi veličinu
Generiranje minijature visoke rezolucije koja će se prikazivati u kvadratu od 80 piksela poput je plaćanja izložbenog otiska samo da bi se stavio u novčanik. Lijek je prestati prepustiti ovaj izbor hiru developera i umjesto toga izvesti ga iz deklarirane namjene. Rječnik generate_for_usage dijeli slučajeve u tri obitelji: mali web formati—minijature i avatari—kojima odgovara low; standardna web upotreba—zaglavlja blogova, objave na društvenim mrežama—koji zahtijevaju medium; i mediji gdje je finoća doista bitna—hero baneri, A4 tisak, portfelji—koji opravdavaju high. Posljednja dva poziva ilustriraju jaz: ista mačka astronaut košta višestruko više ovisno o tome završava li kao minijatura ili kao banner naslovnice.
from openai import OpenAI
import base64
client = OpenAI()
def generate_for_usage(prompt: str, usage: str, output: str):
"""Automatski odabire optimalnu rezoluciju i kvalitetu."""
configs = {
# Mala web upotreba
"thumbnail": {"size": "1024x1024", "quality": "low"},
"avatar": {"size": "1024x1024", "quality": "low"},
# Standardna web upotreba
"blog_header": {"size": "1536x1024", "quality": "medium"},
"social_post": {"size": "1024x1024", "quality": "medium"},
# Upotreba visoke kvalitete
"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"Namjena {usage} ({config['quality']}/{config['size']}) → {output}")
generate_for_usage("Slatka mačka u odijelu astronauta", "thumbnail", "cat_thumb.png")
generate_for_usage("Slatka mačka u odijelu astronauta", "hero_banner", "cat_hero.png")
Uredi umjesto ponovnog generiranja
Klijent odobrava fotografiju, ali želi drugačije nebo. Prirodni refleks—ponovno pokretanje punog generiranja s prilagođenim promptom—navodi te da platiš cijelu sliku i, što je gore, gubiš ostatak kompozicije koji su svi odobrili. images.edit() rješava ovu situaciju po cijeni jednog uređivanja: funkcija edit_detail gradi masku koja oslobađa samo relevantni pravokutnik, ovdje gornjih 300 piksela visine koji odgovaraju nebu, a prompt opisuje samo sadržaj te trake. Sam pejzaž se ne pomiče ni za piksel.
import base64
from openai import OpenAI
from PIL import Image, ImageDraw
client = OpenAI()
# Umjesto ponovnog generiranja cijele slike za promjenu detalja,
# uredi samo relevantno područje.
def edit_detail(image_path: str, zone: tuple, new_content: str, output: str):
"""
Uređuje detalj u postojećoj slici.
zone: (x1, y1, x2, y2) područja za modificiranje
"""
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"Detalj uređen: {output}")
print("Trošak: 1 uređivanje umjesto 1 punog generiranja")
# Primjer: promijeni samo nebo na fotografiji
edit_detail(
"landscape.png",
(0, 0, 1024, 300),
"Plavo nebo s nekoliko pahuljastih bijelih oblaka",
"landscape_sky_edited.png"
)
Znaj kamo novac odlazi
Četiri prethodne strategije pretpostavljaju da znaš što trošiš, a ta vidljivost ne dolazi automatski: nadzorna ploča pružatelja usluge daje ti ukupni iznos, a ne raščlambu po projektu ili kvaliteti. Lokalni zapis (log) popunjava ovaj jaz uz zanemariv trošak razvoja. log_generation dodaje vremenski označeni redak za svaki poziv, skraćujući prompt na 100 znakova kako bi ostao čitljiv, a usage_report zatim agregira sve po razini kvalitete. Ova raščlamba pokreće odluke: ako tvoj zapis otkrije da se 80% tvojih slika generira u high kvaliteti dok većina završava na društvenim mrežama, upravo si pronašao svoj izvor ušteda.
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):
"""Bilježi svako generiranje radi praćenja troškova."""
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():
"""Prikazuje izvještaj o potrošnji."""
if not os.path.exists(USAGE_FILE):
print("Nema podataka o potrošnji.")
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"Ukupno generiranja: {total}")
print(f"Raščlamba po kvaliteti:")
for q, count in sorted(by_quality.items()):
print(f" {q}: {count} slika")
usage_report()
Gdje započeti
Ne nude sve ove strategije isti povrat uloženog truda, a sljedeća tablica pomaže ti da ih prioritetiziraš.
| Strategija | Procijenjene uštede | Trud |
|---|---|---|
| Niska kvaliteta za prototipove | 50-70% | Minimalan |
| Predmemorija promptova | 10-30% (ako se ponavlja) | Umjeren |
| Prilagođena rezolucija | 20-40% | Minimalan |
| Uređivanje naspram ponovnog generiranja | 30-50% (po modifikaciji) | Umjeren |
| Praćenje troškova | Neizravno (vidljivost) | Umjeren |
Dva retka jasno se ističu: prototipiranje u low i prilagođavanje rezolucije namjeni zahtijevaju minimalan trud za polovicu mogućih ušteda. Započni s time, a zatim dodaj predmemoriju i ciljano uređivanje kada tvoj obujam to opravda. Samo praćenje troškova ne štedi ništa izravno—ali ono je ono što ti govori koje od ostale četiri strategije zapravo rađaju plodom u tvom specifičnom kontekstu.
Najbolji način da prestaneš razmišljati o tome jest encapsulirati ova pravila u jednu kontrolnu točku. Napiši omotač (wrapper) oko client.images.generate() koji integrira predmemoriju promptova, automatsko prilagođavanje kvalitete i rezolucije na temelju deklarirane namjene te bilježenje svakog poziva; zatim ga pokreni na deset generiranja i pročitaj izvještaj o potrošnji. Od tog trenutka, cijeli tvoj tim štedi novac bez potrebe da se bilo čega sjeća.