Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Optimiziraj stroške

Lekcija 11 od 12 Posodobljeno 2. november 2026 Razvijalec
Na tej strani
  1. Optimiziraj stroške
  2. Razumevanje strukture stroškov
  3. Prototipiraj v nizki, dostavi v visoki kakovosti
  4. Nikoli ne plačaj dvakrat za isto sliko
  5. Natančno določi velikost
  6. Uredi namesto ponovnega generiranja
  7. Vedi, kam gre denar
  8. Kje začeti

Posodobljeno 2. novembra 2026 — Modeli za slike. Model gpt-image-1, za katerega je bil ta tečaj prvotno napisan, je bil ukinjen 23. oktobra 2026. Modela gpt-image-1.5 in gpt-image-1-mini ter chatgpt-image-latest bosta umaknjena 1. decembra 2026. Primeri zdaj uporabljajo gpt-image-2.5-sunburst, ki ponuja najvišjo natančnost za urejanje; gpt-image-2.5-flare je hitrejši za standardno generiranje. Oba modela podpirata tudi ravni kakovosti xhigh in max. Modeli GPT Image vedno vrnejo slike v formatu base64: parameter response_format iz starejših modelov DALL·E ni več sprejet in je bil odstranjen iz kode. Vir: Generiranje slik (OpenAI).

Optimiziraj stroške

V proizvodnem okolju generiranje slik preneha biti tehnična zanimivost in postane proračunska postavka. Vsaka ekipa, ki mesečno ustvari nekaj sto vizualov, to hitro opazi. Prvi odziv – omejitev uporabe – je tudi najmanj pameten. Ta lekcija pokriva pet strategij, ki zmanjšajo stroške brez ogrožanja kakovosti vaših izdelkov, ker ciljajo na tisto, kar zavržete, in ne na tisto, kar obdržite.

Razumevanje strukture stroškov

Stroški generiranja so odvisni od treh dejavnikov.

DejavnikiVpliv na stroške
Kakovost (low, medium, high)Neposredni množitelj
Ločljivost (1024, 1536)Večje = dražje
Število slik (n)Linearni strošek (n × cena na enoto)

Ti trije dejavniki se med seboj množijo, kar pojasnjuje, zakaj nedisciplinirano raziskovanje stane za red velikosti več kot enako raziskovanje, izvedeno z disciplino. Spodnja skripta našteva pet kombinacij, s katerimi se boste v proizvodnji najpogosteje srečali. Čeprav se točni zneski pojavijo na vaši nadzorni plošči OpenAI, vrstni red vrstic že kaže obseg kompromisov.

from openai import OpenAI

client = OpenAI()

# Primerjava stroškov: enak poziv, različni parametri
configs = [
    {"quality": "low", "size": "1024x1024", "label": "Nizka / 1024"},
    {"quality": "medium", "size": "1024x1024", "label": "Srednja / 1024"},
    {"quality": "high", "size": "1024x1024", "label": "Visoka / 1024"},
    {"quality": "medium", "size": "1536x1024", "label": "Srednja / 1536"},
    {"quality": "high", "size": "1536x1024", "label": "Visoka / 1536"},
]

print("Konfiguracija          | Uporaba (ocena)")
print("-" * 50)
for config in configs:
    print(f"{config['label']:22s} | Preveri svojo nadzorno ploščo OpenAI")

Prototipiraj v nizki, dostavi v visoki kakovosti

To je daleč najbolj stroškovno učinkovita strategija in najlažja za sprejetje. V fazi raziskovanja ne ocenjuješ finesse gradienta: ocenjuješ kompozicijo, kadrirovanje in splošno vzdušje, kar je vse popolnoma vidno pri quality: low. Preklop na high ima smisel šele za sliko, ki jo dejansko nameravaš objaviti. Spodnji delovni tok formalizira to zaporedje tako, da proizvede pet ekonomičnih osnutkov, ki jim sledi en sam končni izris, z dodatno prednostjo preklopa na ležeči format (1536×1024) za dokončno različico. Pri petih poskusih in eni dostavi se prihranki, navedeni na koncu skripte, gibljejo okoli 60 % v primerjavi z raziskovanjem, izvedenim v celoti v high.

from openai import OpenAI
import base64

client = OpenAI()

def economical_workflow(prompt: str, output: str, n_drafts: int = 5):
    """
    Dvofazni delovni tok:
    1. Hitri osnutki v nizki kakovosti
    2. Končni izris v visoki kakovosti
    """
    # Faza 1: Hitro raziskovanje
    print("Faza 1: hitri osnutki (nizka kakovost)")
    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"  Osnutek {i+1}: {path}")

    # Faza 2: Končni izris (po človeški izbiri najboljšega osnutka)
    print("\nFaza 2: končni izris (visoka kakovost)")
    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"  Končni izris: {output}")

    # Povzetek: 5 nizkih + 1 visok namesto 5 visokih
    print(f"\nPovzetek: {n_drafts} nizkih osnutkov + 1 končni visok")
    print("Ocenjeni prihranki: ~60 % v primerjavi z raziskovanjem samo v visoki kakovosti")


economical_workflow(
    "Ilustracija zelenega tehnološkega kampusa s sončnimi celicami, arhitekturni slog",
    "campus_final.png"
)

Nikoli ne plačaj dvakrat za isto sliko

V realni aplikaciji se isti poziv vrača veliko pogosteje, kot bi morda pričakoval: uporabnik osveži stran, skripta za gradnjo ponovno zažene generiranje ali ikona se ponovno uporabi na treh straneh. Vsak od teh primerov predstavlja nepotreben strošek. Spodnji predpomnilnik jih odpravi z izračunom haša SHA-256 trojčka (poziv, velikost, kakovost) – treh elementov, ki določajo zaračunani rezultat – in okrajšanjem tega haša na šestnajst znakov za ustvarjanje obvladljivega imena datoteke. Opazi preverjanje os.path.exists: indeks morda pozna vnos, katerega datoteka je bila izbrisana z diska; v tem primeru koda sliko ponovno generira, namesto da bi vrnila mrtvo pot.

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:
    """Naloži indeks predpomnilnika."""
    if os.path.exists(CACHE_INDEX):
        with open(CACHE_INDEX, "r") as f:
            return json.load(f)
    return {}

def save_cache(cache: dict):
    """Shrani indeks predpomnilnika."""
    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 sliko ali vrne predpomnjeni rezultat."""
    # Ustvari edinstven ključ na podlagi 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"Zadetek v predpomnilniku: {cached_path}")
            return cached_path
        else:
            print("Predpomnilnik je potekel, ponovno generiranje...")

    # Ni v predpomnilniku: 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 in predpomnjeno: {path}")
    return path


# Prvo generiranje: klic API-ja
path1 = generate_with_cache("Minimalistični logotip za tehnološki startup, modra in bela")
# Drugi enak klic: postreženo iz predpomnilnika
path2 = generate_with_cache("Minimalistični logotip za tehnološki startup, modra in bela")

Natančno določi velikost

Generiranje sličice v visoki ločljivosti, ki bo prikazana v kvadratu velikosti 80 pikslov, je kot plačilo za razstavni tisk samo zato, da ga spraviš v denarnico. Zdravilo je, da te izbire ne prepustiš muham razvijalca, temveč jo izpelješ iz deklarirane uporabe. Slovar generate_for_usage primere razdeli v tri družine: majhni spletni formati – sličice in avatarji – ki so zadovoljni z low; standardna spletna uporaba – naslovne slike blogov, objave na družbenih omrežjih – ki zahtevajo medium; in mediji, kjer je finesse res pomembna – glavne pasice, tisk A4, portfolii – ki upravičujejo high. Zadnja dva klica ilustrirata razliko: isti maček astronavt stane večkratnik, odvisno od tega, ali konča kot sličica ali kot pasica na domači strani.

from openai import OpenAI
import base64

client = OpenAI()

def generate_for_usage(prompt: str, usage: str, output: str):
    """Samodejno izbere optimalno ločljivost in kakovost."""
    configs = {
        # Majhna spletna uporaba
        "thumbnail": {"size": "1024x1024", "quality": "low"},
        "avatar": {"size": "1024x1024", "quality": "low"},

        # Standardna spletna uporaba
        "blog_header": {"size": "1536x1024", "quality": "medium"},
        "social_post": {"size": "1024x1024", "quality": "medium"},

        # Uporaba visoke kakovosti
        "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"Uporaba {usage} ({config['quality']}/{config['size']}) → {output}")


generate_for_usage("Srčkan maček v astronavtski obleki", "thumbnail", "cat_thumb.png")
generate_for_usage("Srčkan maček v astronavtski obleki", "hero_banner", "cat_hero.png")

Uredi namesto ponovnega generiranja

Stranka odobri fotografijo, a želi drugačno nebo. Naravni refleks – ponovno zagon celotnega generiranja s prilagojenim pozivom – te prisili, da plačaš za celotno sliko in, kar je še huje, izgubiš preostanek kompozicije, ki so jo vsi odobrili. images.edit() obravnava to situacijo po ceni urejanja: funkcija edit_detail zgradi masko, ki sprosti samo ustrezen pravokotnik, tukaj zgornjih 300 pikslov višine, ki ustrezajo nebu, poziv pa opisuje samo vsebino tega pasu. Sama pokrajina se ne premakne niti za piksel.

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

client = OpenAI()

# Namesto ponovnega generiranja celotne slike za spremembo podrobnosti
# uredi samo ustrezno območje.

def edit_detail(image_path: str, zone: tuple, new_content: str, output: str):
    """
    Uredi podrobnost v obstoječi sliki.
    zone: (x1, y1, x2, y2) območja za spremembo
    """
    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"Podrobnost urejena: {output}")
    print("Strošek: 1 urejanje namesto 1 celotnega generiranja")


# Primer: spremeni samo nebo na fotografiji
edit_detail(
    "landscape.png",
    (0, 0, 1024, 300),
    "Modro nebo z nekaj puhastimi belimi oblaki",
    "landscape_sky_edited.png"
)

Vedi, kam gre denar

Štiri prejšnje strategije predpostavljajo, da veš, kaj porabljaš, in ta vidljivost ne pride samodejno: nadzorna plošča ponudnika ti da vsoto, ne pa razčlenitve po projektu ali kakovosti. Lokalni dnevnik to vrzel zapolni za zanemarljive razvojne stroške. log_generation doda časovno označeno vrstico za vsak klic in okrajša poziv na 100 znakov, da ostane berljiv, usage_report pa nato vse združi po ravni kakovosti. Ta razčlenitev sproži odločitve: če tvoj dnevnik razkrije, da je 80 % tvojih slik generiranih v high, medtem ko večina konča na objavah v družbenih omrežjih, si pravkar našel svoj vir prihrankov.

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):
    """Zabeleži vsako generiranje za sledenje stroškom."""
    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():
    """Prikaže poročilo o porabi."""
    if not os.path.exists(USAGE_FILE):
        print("Ni podatkov o porabi.")
        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"Skupno generiranj: {total}")
    print(f"Razčlenitev po kakovosti:")
    for q, count in sorted(by_quality.items()):
        print(f"  {q}: {count} slik")


usage_report()

Kje začeti

Vse te strategije ne ponujajo enakega donosa glede na vložen trud, spodnja tabela pa ti pomaga pri določanju prioritet.

StrategijaOcenjeni prihrankiTrud
Nizka kakovost za prototipiranje50–70 %Minimalen
Predpomnjenje pozivov10–30 % (če se ponavlja)Zmeren
Prilagojena ločljivost20–40 %Minimalen
Urejanje namesto ponovnega generiranja30–50 % (na spremembo)Zmeren
Sledenje stroškomPosredno (vidljivost)Zmeren

Dve vrstici izstopata jasno: prototipiranje v low in prilagajanje ločljivosti uporabi zahtevata minimalen trud za polovico možnih prihrankov. Začni s tema, nato dodaj predpomnjenje in ciljno urejanje, ko tvoj obseg to upraviči. Sledenje stroškom samo po sebi ne prihrani ničesar neposredno – a prav to ti pove, katera od drugih štirih dejansko obrodi sadove v tvojem specifičnem kontekstu.

Najboljši način, da prenehaš razmišljati o tem, je encapsulacija teh pravil v eno samo ozko grlo. Napiši ovojnico okoli client.images.generate(), ki integrira predpomnjenje pozivov, samodejno prilagajanje kakovosti in ločljivosti na podlagi deklarirane uporabe ter beleženje vsakega klica; nato jo zaženi na desetih generiranjih in preberi poročilo o porabi. Od tam naprej cela tvoja ekipa varčuje z denarjem, ne da bi se morala česa spominjati.