Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Kulude optimeerimine

Õppetund 11 / 12 Värskendatud 2. november 2026 Arendajatele
Sellel lehel
  1. Kulude optimeerimine
  2. Mõista kulustruktuuri
  3. Prototüübi madalas, edasta kõrges
  4. Ära maksa kunagi kaks korda sama pildi eest
  5. Määra suurus täpselt
  6. Redigeeri asemel, et uuesti genereerida
  7. Tea, kuhu raha läheb
  8. Kust alustada

Uuendatud 2. novembril 2026 — Pildimudelid. Mudel gpt-image-1, mille jaoks see kursus algselt kirjutati, lõpetas tegevuse 23. oktoobril 2026. Mudelid gpt-image-1.5, gpt-image-1-mini ja chatgpt-image-latest võetakse kasutusest maha 1. detsembril 2026. Näited kasutavad nüüd mudelit gpt-image-2.5-sunburst, mis pakub redigeerimisel suurimat täpsust; gpt-image-2.5-flare on tavapäraseks genereerimiseks kiirem. Mõlemad mudelid toetavad ka kvaliteeditasemeid xhigh ja max. GPT Image mudelid tagastavad pildid alati base64-vormingus: vanemate DALL·E mudelite parameeter response_format ei ole enam aktsepteeritud ja on koodist eemaldatud. Allikas: Pildigeneratsioon (OpenAI).

Kulude optimeerimine

Tootmises lakkab pildigeneratsioon olemast tehniline uudishimu ja muutub eelarvereaiks. Iga meeskond, mis toodab kuus mõnisada visuaali, märkab seda kiiresti. Esimene reaktsioon – kasutuse piiramine – on samal ajal ka kõige vähem tark. See tund käsitleb viit strateegiat, mis vähendavad kulusid ilma sinu tööde kvaliteeti ohverdamata, sest need sihtivad seda, mida sa viskad minna, mitte seda, mida sa alles hoiad.

Mõista kulustruktuuri

Generatsioonikulud sõltuvad kolmest tegurist.

TegurMõju kulule
Kvaliteet (low, medium, high)Otsene kordaja
Resolutsioon (1024, 1536)Suurem = kallim
Piltide arv (n)Lineaarne kulu (n × ühiku hind)

Need kolm tegurit korrutavad üksteist, mis seletab, miks distsiplineerimata katsetamine maksab suurusjärgu võrra rohkem kui sama katsetamine distsiplineeritult. Allpool olev skript loetleb viis kombinatsiooni, mida tootmises kõige sagedamini kohtad. Kuigi täpsed summad ilmuvad sinu OpenAI armatuurlauale, näitavad ridade järjekord juba kompromisside ulatust.

from openai import OpenAI

client = OpenAI()

# Võrdle kulusid: sama vihje, erinevad parameetrid
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("Konfiguratsioon         | Kasutus (hinnanguline)")
print("-" * 50)
for config in configs:
    print(f"{config['label']:22s} | Kontrolli oma OpenAI armatuurlauda")

Prototüübi madalas, edasta kõrges

See on kaugelt kõige kulutõhusam strateegia ja lihtsaim omaks võtta. Uurimisfaasis ei hinda sa gradiendi peenust: sa hindad kompositsiooni, kaadrit ja üldist meeleolu, mis on kõik täiuslikult nähtavad tasemel quality: low. Üleminek tasemele high on mõttekas ainult selle pildi puhul, mida tegelikult avaldada kavatsetad. Allpool olev töövoog vormistab selle järjestuse, luues viis ökonoomset mustandit, millele järgneb üksainus lõplik renderdus, lisakasuna lülitudes lõpliku versiooni jaoks maastikuformaati (1536×1024). Viie katse ja ühe edastuse korral kõigub skripti lõpus mainitud kokkuhoid umbes 60% võrreldes uurimisega, mis on läbi viidud täielikult tasemel high.

from openai import OpenAI
import base64

client = OpenAI()

def economical_workflow(prompt: str, output: str, n_drafts: int = 5):
    """
    Kahefaasiline töövoog:
    1. Kiired mustandid madalas kvaliteedis
    2. Lõplik renderdus kõrges kvaliteedis
    """
    # 1. faas: Kiire uurimine
    print("1. faas: kiired mustandid (madal kvaliteet)")
    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"  Mustand {i+1}: {path}")

    # 2. faas: Lõplik renderdus (pärast inimese poolt parima mustandi valimist)
    print("\n2. faas: lõplik renderdus (kõrge kvaliteet)")
    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"  Lõplik renderdus: {output}")

    # Kokkuvõte: 5 madalat + 1 kõrge 5 kõrge asemel
    print(f"\nKokkuvõte: {n_drafts} madalat mustandit + 1 lõplik kõrge")
    print("Hinnanguline kokkuhoid: ~60% võrreldes täielikult kõrge kvaliteediga uurimisega")


economical_workflow(
    "Illustratsioon rohelise tehnoloogia ülikoolilinnakust päikesepaneelidega, arhitektuuriline stiil",
    "campus_final.png"
)

Ära maksa kunagi kaks korda sama pildi eest

Reaalses rakenduses kordub sama vihje palju sagedamini, kui arvata oskad: kasutaja värskendab lehte, buildi-skript käivitab genereerimise uuesti või ikooni kasutatakse uuesti kolmel lehel. Iga neist juhtumitest on tarbetu kulu. Allpool olev vahemälu kõrvaldab need, arvutades kolmiku (vihje, suurus, kvaliteet) SHA-256 räsi – need on kolm elementi, mis määravad arveldatava tulemuse – ja lühendades selle räsi kuuetekümne neljast tähemärgist kuuetekümne neljale, et luua hallatav failinimi. Pane tähele kontrolli os.path.exists: indeks võib teada kirjet, mille fail on kettalt kustutatud; sel juhul genereerib kood pildi uuesti, selle asemel et tagastada surnud tee.

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:
    """Laadib vahemälu indeksi."""
    if os.path.exists(CACHE_INDEX):
        with open(CACHE_INDEX, "r") as f:
            return json.load(f)
    return {}

def save_cache(cache: dict):
    """Salvestab vahemälu indeksi."""
    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:
    """Genereerib pildi või tagastab vahemälus oleva tulemuse."""
    # Loo parameetrite põhjal unikaalne võti
    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"Vahemälu tabamus: {cached_path}")
            return cached_path
        else:
            print("Vahemälu aegunud, genereerin uuesti...")

    # Pole vahemälus: genereeri
    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"Genereeritud ja vahemällu salvestatud: {path}")
    return path


# Esimene genereerimine: API väljakutse
path1 = generate_with_cache("Minimalistlik logo tehnoloogia idufirmale, sinine ja valge")
# Teine identne väljakutse: teenindatakse vahemälust
path2 = generate_with_cache("Minimalistlik logo tehnoloogia idufirmale, sinine ja valge")

Määra suurus täpselt

Kõrge resolutsiooniga pisipildi genereerimine, mida kuvatakse 80-pikslises ruudus, on nagu maksaks näituseprindi eest, et see siis rahakotti pista. Abinõuks on lõpetada selle valiku jätmine arendaja tujude hooleks ja tuletada see asemel deklareeritud kasutusest. Sõnastik generate_for_usage jagab juhtumid kolme perekonda: väikesed veebivormingud – pisipildid ja avatarid –, mis saavad hästi hakkama tasemega low; standardne veebikasutus – blogi päised, sotsiaalmeedia postitused –, mis nõuavad taset medium; ja meedia, kus peenus tõesti loeb – kangelasbännerid, A4 trükised, portfooliod –, mis õigustavad taset high. Viimased kaks väljakutset illustreerivad lõhet: sama astronaut-kass maksab kordse summa sõltuvalt sellest, kas ta lõpetab pisipildi või avalehe bännerina.

from openai import OpenAI
import base64

client = OpenAI()

def generate_for_usage(prompt: str, usage: str, output: str):
    """Valib automaatselt optimaalse resolutsiooni ja kvaliteedi."""
    configs = {
        # Väike veebikasutus
        "thumbnail": {"size": "1024x1024", "quality": "low"},
        "avatar": {"size": "1024x1024", "quality": "low"},

        # Standardne veebikasutus
        "blog_header": {"size": "1536x1024", "quality": "medium"},
        "social_post": {"size": "1024x1024", "quality": "medium"},

        # Kõrge kvaliteediga kasutus
        "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"Kasutus {usage} ({config['quality']}/{config['size']}) → {output}")


generate_for_usage("Armas kass astronaudiülikonnas", "thumbnail", "cat_thumb.png")
generate_for_usage("Armas kass astronaudiülikonnas", "hero_banner", "cat_hero.png")

Redigeeri asemel, et uuesti genereerida

Klient kiidab foto heaks, kuid soovib teistsugust taevast. Loomulik refleks – käivitada kogu genereerimine uuesti kohandatud vihjega – paneb sind maksma terve pildi eest ja, mis veel hullem, kaotad kogu ülejäänud kompositsiooni, mille kõik olid heaks kiitnud. images.edit() lahendab selle olukorra ühe redigeerimise hinnaga: funktsioon edit_detail ehitab maski, mis vabastab ainult asjakohase ristküliku, siin ülemised 300 pikslit kõrgusest, mis vastavad taevale, ja vihje kirjeldab ainult selle riba sisu. Maastik ise ei liigu mitte ühtegi pikslit.

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

client = OpenAI()

# Terve pildi uuesti genereerimise asemel detaili muutmiseks
# redigeeri ainult asjakohast ala.

def edit_detail(image_path: str, zone: tuple, new_content: str, output: str):
    """
    Redigeerib detaili olemasoleval pildil.
    zone: (x1, y1, x2, y2) muudetavast alast
    """
    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 redigeeritud: {output}")
    print("Kulu: 1 redigeerimine 1 täieliku genereerimise asemel")


# Näide: muuda ainult foto taevast
edit_detail(
    "landscape.png",
    (0, 0, 1024, 300),
    "Sinine taevas mõne koheva valge pilvega",
    "landscape_sky_edited.png"
)

Tea, kuhu raha läheb

Neli eelmist strateegiat eeldavad, et tead, mida tarbid, ja see nähtavus ei tule automaatselt: teenusepakkuja armatuurlaud annab sulle kogusumma, mitte jaotuse projekti või kvaliteedi järgi. Kohalik logi täidab selle lünga tühise arenduskulu hinnaga. log_generation lisab iga väljakutse jaoks ajatempliga rea, lühendades vihje 100 tähemärgini, et see jääks loetavaks, ja usage_report koondab seejärel kõik kvaliteeditasemete kaupa. See jaotus käivitab otsuseid: kui sinu logi näitab, et 80% sinu piltidest genereeritakse tasemel high, samas kui enamik neist lõpetab sotsiaalmeedia postitustena, oled just leidnud oma kokkuhoiu allika.

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):
    """Logib iga genereerimise kulude jälgimiseks."""
    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():
    """Kuvab tarbimisaruande."""
    if not os.path.exists(USAGE_FILE):
        print("Tarbimisandmed puuduvad.")
        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"Generatsioone kokku: {total}")
    print(f"Jaotus kvaliteedi järgi:")
    for q, count in sorted(by_quality.items()):
        print(f"  {q}: {count} pilti")


usage_report()

Kust alustada

Kõik need strateegiad ei paku sama tootlust pingutuse suhtes ja järgnev tabel aitab sul neid prioriteetsuse järjekorda seada.

StrateegiaHinnanguline kokkuhoidPingutus
Madal prototüüpimiseks50–70%Minimaalne
Vihjete vahemälu10–30% (kui korduv)Mõõdukas
Kohandatud resolutsioon20–40%Minimaalne
Redigeerimine vs uuesti genereerimine30–50% (muudatuse kohta)Mõõdukas
Kulude jälgimineKaudne (nähtavus)Mõõdukas

Kaks rida paistavad selgelt silma: prototüüpimine tasemel low ja resolutsiooni kohandamine kasutusele nõuavad minimaalset pingutust poole võimaliku kokkuhoiu eest. Alusta nendest ja lisa seejärel vahemälu ja sihipärane redigeerimine, kui sinu maht seda õigustab. Kulude jälgimine ise ei säästa otseselt midagi – kuid just see ütleb sulle, millised neljast ülejäänust tegelikult sinu konkreetses kontekstis vilja kannavad.

Parim viis sellele mitte mõtlemiseks on kapseldada need reeglid ühte ainsasse kitsaskohta. Kirjuta mähis funktsiooni client.images.generate() ümber, mis integreerib vihjete vahemälu, automaatse kvaliteedi ja resolutsiooni kohandamise deklareeritud kasutuse põhjal ning iga väljakutse logimise; seejärel käivita see kümnel genereerimisel ja loe tarbimisaruannet. Sealt edasi säästab kogu sinu meeskond raha, pidamata midagi meeles.