Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Optimiziraj troškove

Lekcija 11 od 12 Ažurirano 2. studenoga 2026. Programer
Na ovoj stranici
  1. Optimiziraj troškove
  2. Razumijevanje strukture troškova
  3. Prototipiraj u niskoj, isporučuj u visokoj kvaliteti
  4. Nikada ne plaćaj dvaput za istu sliku
  5. Precizno odredi veličinu
  6. Uredi umjesto ponovnog generiranja
  7. Znaj kamo novac odlazi
  8. Gdje započeti

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.. Modeli gpt-image-1.5, gpt-image-1-mini i chatgpt-image-latest bit će povučeni iz upotrebe 1. prosinca 2026.. Primjeri sada koriste gpt-image-2.5-sunburst, koji nudi najveću preciznost za uređivanje; gpt-image-2.5-flare je brži za standardno generiranje. Oba modela također podržavaju razine kvalitete xhigh i max. GPT Image modeli uvijek vraćaju slike u base64 formatu: parametar response_format iz 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.

FaktorUtjecaj 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š.

StrategijaProcijenjene uštedeTrud
Niska kvaliteta za prototipove50-70%Minimalan
Predmemorija promptova10-30% (ako se ponavlja)Umjeren
Prilagođena rezolucija20-40%Minimalan
Uređivanje naspram ponovnog generiranja30-50% (po modifikaciji)Umjeren
Praćenje troškovaNeizravno (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.