Kulude optimeerimine
Sellel lehel
Uuendatud 2. novembril 2026 — Pildimudelid. Mudel
gpt-image-1, mille jaoks see kursus algselt kirjutati, lõpetas tegevuse 23. oktoobril 2026. Mudelidgpt-image-1.5,gpt-image-1-minijachatgpt-image-latestvõetakse kasutusest maha 1. detsembril 2026. Näited kasutavad nüüd mudelitgpt-image-2.5-sunburst, mis pakub redigeerimisel suurimat täpsust;gpt-image-2.5-flareon tavapäraseks genereerimiseks kiirem. Mõlemad mudelid toetavad ka kvaliteeditasemeidxhighjamax. GPT Image mudelid tagastavad pildid alati base64-vormingus: vanemate DALL·E mudelite parameeterresponse_formatei 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.
| Tegur | Mõ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.
| Strateegia | Hinnanguline kokkuhoid | Pingutus |
|---|---|---|
| Madal prototüüpimiseks | 50–70% | Minimaalne |
| Vihjete vahemälu | 10–30% (kui korduv) | Mõõdukas |
| Kohandatud resolutsioon | 20–40% | Minimaalne |
| Redigeerimine vs uuesti genereerimine | 30–50% (muudatuse kohta) | Mõõdukas |
| Kulude jälgimine | Kaudne (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.