Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Optimoi kustannuksia

Oppitunti 11 / 12 Päivitetty 2. marraskuuta 2026 Kehittäjä
Tällä sivulla
  1. Optimoi kustannuksia
  2. Ymmärrä kustannusrakenne
  3. Tee prototyypit matalalla laadulla, toimita korkealla
  4. Älä maksa kahdesti samasta kuvasta
  5. Mitoita tarkasti
  6. Muokkaa äläkä generoi uudelleen
  7. Tiedä, mihin raha menee
  8. Mistä aloittaa

Päivitetty 2. marraskuuta 2026 — Kuvamallit. gpt-image-1, malli, jota varten tämä kurssi alun perin kirjoitettiin, lopetettiin 23. lokakuuta 2026. gpt-image-1.5, gpt-image-1-mini ja chatgpt-image-latest poistuvat käytöstä 1. joulukuuta 2026. Esimerkit käyttävät nyt mallia gpt-image-2.5-sunburst, joka tarjoaa korkeimman tarkkuuden muokkaukseen; gpt-image-2.5-flare on nopeampi tavanomaiseen generointiin. Molemmat mallit tukevat myös laatu­tasoja xhigh ja max. GPT Image -mallit palauttavat kuvat aina base64-muodossa: vanhempien DALL·E-mallien response_format-parametria ei enää hyväksytä, ja se on poistettu koodista. Lähde: Image generation (OpenAI).

Optimoi kustannuksia

Tuotantoympäristössä kuvien generointi lakkaa olemasta pelkkä tekninen kuriositeetti ja muuttuu budjettikohteeksi. Mikä tahansa tiimi, joka tuottaa muutaman sadan visuaalisen elementin kuukaudessa, huomaa tämän nopeasti. Ensimmäinen reaktio – käytön rajoittaminen – on myös vähiten älykäs. Tämä oppitunti käsittelee viittä strategiaa, jotka vähentävät kustannuksia vaarantamatta tuotosten laatua, koska ne kohdistuvat siihen, mitä hylkäät, eivät siihen, mitä säilytät.

Ymmärrä kustannusrakenne

Generointikustannukset riippuvat kolmesta tekijästä.

TekijäVaikutus kustannuksiin
Laatu (low, medium, high)Suora kerroin
Resoluutio (1024, 1536)Suurempi = kalliimpi
Kuvien määrä (n)Lineaarinen kustannus (n × yksikköhinta)

Nämä kolme tekijää kertovat toisensa, mikä selittää, miksi kuriton kokeilu maksaa suuruusluokkaa enemmän kuin sama kokeilu, joka suoritetaan kurinalaisesti. Alla oleva skripti listaa viisi yhdistelmää, jotka kohtaat useimmiten tuotannossa. Vaikka tarkat summat näkyvät OpenAI-kojelaudallasi, rivien järjestys itsessään paljastaa kompromissien mittakaavan.

from openai import OpenAI

client = OpenAI()

# Vertaa kustannuksia: sama kehote, eri parametrit
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("Konfiguraatio          | Käyttö (arvioitu)")
print("-" * 50)
for config in configs:
    print(f"{config['label']:22s} | Tarkista OpenAI-kojelautasi")

Tee prototyypit matalalla laadulla, toimita korkealla

Tämä on ylivoimaisesti kustannustehokkain strategia, ja helpoin omaksua. Tutkimusvaiheessa et arvostele gradientin hienovaraisuutta: arvioit sommittelua, rajauksia ja yleistä tunnelmaa, jotka kaikki näkyvät täydellisesti asetuksella quality: low. Siirtyminen asetukseen high on järkevää vasta sille kuvalle, jonka aiot todella julkaista. Alla oleva työnkulku formalisoi tämän sekvenssin tuottamalla viisi taloudellista luonnosta, joita seuraa yksi lopullinen renderöinti, lisäetuna siirtyminen vaakasuuntaiseen muotoon (1536×1024) lopullista versiota varten. Viiden kokeilun ja yhden toimituksen kokonaisuudessa skriptin lopussa mainitut säästöt ovat noin 60 % verrattuna tutkimukseen, joka suoritettaisiin kokonaan laadulla high.

from openai import OpenAI
import base64

client = OpenAI()

def economical_workflow(prompt: str, output: str, n_drafts: int = 5):
    """
    Kaksivaiheinen työnkulku:
    1. Nopeat luonnokset matalalla laadulla
    2. Lopullinen renderöinti korkealla laadulla
    """
    # Vaihe 1: Nopea tutkimus
    print("Vaihe 1: nopeat luonnokset (matala laatu)")
    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"  Luonnos {i+1}: {path}")

    # Vaihe 2: Lopullinen renderöinti (sen jälkeen kun paras luonnos on valittu manuaalisesti)
    print("\nVaihe 2: lopullinen renderöinti (korkea laatu)")
    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"  Lopullinen renderöinti: {output}")

    # Yhteenveto: 5 matalaa + 1 korkea 5 korkean sijaan
    print(f"\nYhteenveto: {n_drafts} matalan laadun luonnosta + 1 lopullinen korkealla laadulla")
    print("Arvioidut säästöt: ~60 % verrattuna kokonaan korkealla laadulla tehtyyn tutkimukseen")


economical_workflow(
    "Kuvitus vihreän teknologian kampuksesta aurinkopaneeleineen, arkkitehtoninen tyyli",
    "campus_final.png"
)

Älä maksa kahdesti samasta kuvasta

Todellisessa sovelluksessa sama kehote toistuu paljon useammin kuin luulisit: käyttäjä päivittää sivun, build-skripti ajaa generoinnin uudelleen tai kuvaketta käytetään uudelleen kolmella eri sivulla. Jokainen näistä tapauksista on tarpeeton maksu. Alla oleva välimuisti poistaa nämä laskemalla SHA-256-hashin kolmikosta (kehote, koko, laatu) – kolme elementtiä, jotka määrittävät laskutettavan tuloksen – ja lyhentämällä tämän hashin kuuteentoista merkkiin hallittavan tiedostonimen luomiseksi. Huomaa os.path.exists-tarkistus: indeksi saattaa tuntea merkinnän, jonka tiedosto on poistettu levyltä, jolloin koodi generoi kuvan uudelleen sen sijaan, että palauttaisi kuolleen polun.

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:
    """Lataa välimuistin indeksin."""
    if os.path.exists(CACHE_INDEX):
        with open(CACHE_INDEX, "r") as f:
            return json.load(f)
    return {}

def save_cache(cache: dict):
    """Tallentaa välimuistin indeksin."""
    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:
    """Generoi kuvan tai palauttaa välimuistissa olevan tuloksen."""
    # Luo uniikki avain parametrien perusteella
    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"Osuma välimuistissa: {cached_path}")
            return cached_path
        else:
            print("Välimuisti vanhentunut, generoidaan uudelleen...")

    # Ei välimuistissa: generoi
    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"Generoitu ja tallennettu välimuistiin: {path}")
    return path


# Ensimmäinen generointi: API-kutsu
path1 = generate_with_cache("Minimalistinen logo tech-startupille, sininen ja valkoinen")
# Toinen identtinen kutsu: palautetaan välimuistista
path2 = generate_with_cache("Minimalistinen logo tech-startupille, sininen ja valkoinen")

Mitoita tarkasti

Korkearesoluutioisen pikkukuvan generointi, joka näytetään 80 pikselin neliössä, on kuin maksaisi näyttelypainoksesta vain liukastaakseen sen lompakkoon. Ratkaisu on lopettaa tämän valinnan jättäminen kehittäjän mielivallan varaan ja johtaa se sen sijaan ilmoitetusta käyttötarkoituksesta. Sanakirja generate_for_usage jakaa tapaukset kolmeen perheeseen: pienet web-muodot – pikkukuvat ja avatarit – jotka toimivat hyvin laadulla low; tavanomainen web-käyttö – blogin otsikkokuvat, some-julkaisut – jotka vaativat laatua medium; ja media, jossa hienovaraisuus todella merkitsee – hero-bannerit, A4-tulosteet, portfoliot – jotka oikeuttavat laadun high. Kaksi viimeistä kutsua havainnollistavat kuilua: sama astronauttikissa maksaa moninkertaisesti riippuen siitä, päätyykö se pikkukuvaksi vai etusivun banneriksi.

from openai import OpenAI
import base64

client = OpenAI()

def generate_for_usage(prompt: str, usage: str, output: str):
    """Valitsee automaattisesti optimaalisen resoluution ja laadun."""
    configs = {
        # Pieni web-käyttö
        "thumbnail": {"size": "1024x1024", "quality": "low"},
        "avatar": {"size": "1024x1024", "quality": "low"},

        # Tavanomainen web-käyttö
        "blog_header": {"size": "1536x1024", "quality": "medium"},
        "social_post": {"size": "1024x1024", "quality": "medium"},

        # Korkealaatuinen käyttö
        "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"Käyttötarkoitus {usage} ({config['quality']}/{config['size']}) → {output}")


generate_for_usage("Söpö kissa astronautin asussa", "thumbnail", "cat_thumb.png")
generate_for_usage("Söpö kissa astronautin asussa", "hero_banner", "cat_hero.png")

Muokkaa äläkä generoi uudelleen

Asiakas hyväksyy valokuvan, mutta haluaa erilaisen taivaan. Luonnollinen refleksi – koko generoinnin uudelleenajo säädetyllä kehotteella – saa sinut maksamaan koko kuvasta ja, mikä pahempaa, menettämään loput sommittelusta, jonka kaikki olivat jo hyväksyneet. images.edit() hoitaa tämän tilanteen yhden muokkauksen hinnalla: funktio edit_detail rakentaa maskin, joka vapauttaa vain relevantin suorakulmion, tässä tapauksessa ylemmät 300 pikseliä korkeutta vastaamaan taivasta, ja kehote kuvailee vain tämän kaistaleen sisältöä. Itse maisema ei liiku pixeliäkään.

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

client = OpenAI()

# Koko kuvan uudelleengeneroinnin sijaan yksityiskohdan muuttamiseksi,
# muokkaa vain relevanttia aluetta.

def edit_detail(image_path: str, zone: tuple, new_content: str, output: str):
    """
    Muokkaa yksityiskohtaa olemassa olevassa kuvassa.
    zone: (x1, y1, x2, y2) muokattavasta alueesta
    """
    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"Yksityiskohta muokattu: {output}")
    print("Kustannus: 1 muokkaus 1 täyden generoinnin sijaan")


# Esimerkki: vaihda vain valokuvan taivas
edit_detail(
    "landscape.png",
    (0, 0, 1024, 300),
    "Sininen taivas muutamalla pörröisellä valkoisella pilvellä",
    "landscape_sky_edited.png"
)

Tiedä, mihin raha menee

Neljä edellistä strategiaa olettavat, että tiedät mitä kulutat, eikä tämä näkyvyys tule automaattisesti: tarjoajan kojelauta antaa sinulle kokonaissumman, ei erittelyä projektin tai laadun mukaan. Paikallinen loki täyttää tämän aukon mitättömällä kehityskustannuksella. log_generation lisää aikaleimatun rivin jokaiselle kutsulle, lyhentäen kehotteen 100 merkkiin luettavuuden säilyttämiseksi, ja usage_report aggregoi sitten kaiken laatutason mukaan. Tämä erittely laukaisee päätöksiä: jos lokisi paljastaa, että 80 % kuvistasi generoidaan laadulla high, vaikka päätyvät enimmäkseen some-julkaisuihin, olet juuri löytänyt säästöpotentiaalisi.

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):
    """Lokittaa jokaisen generoinnin kustannusten seuraamiseksi."""
    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():
    """Näyttää kulutusraportin."""
    if not os.path.exists(USAGE_FILE):
        print("Ei kulutusdataa.")
        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"Generointeja yhteensä: {total}")
    print(f"Erittely laadun mukaan:")
    for q, count in sorted(by_quality.items()):
        print(f"  {q}: {count} kuvaa")


usage_report()

Mistä aloittaa

Kaikki nämä strategiat eivät tarjoa samaa tuottoa vaivaan nähden, ja seuraava taulukko auttaa sinua asettamaan ne tärkeysjärjestykseen.

StrategiaArvioidut säästötVaiva
Matala laatu prototypointiin50–70 %Vähäinen
Kehotteiden välimuisti10–30 % (jos toistuva)Kohtalainen
Mukautettu resoluutio20–40 %Vähäinen
Muokkaus vs. uudelleengenerointi30–50 % (per muutos)Kohtalainen
Kulutuksen seurantaVälillinen (näkyvyys)Kohtalainen

Kaksi riviä erottuvat selvästi: prototypointi laadulla low ja resoluution mukauttaminen käyttötarkoitukseen vaativat vähäistä vaivaa puolesta mahdollisista säästöistä. Aloita niistä, ja lisää välimuisti ja kohdennettu muokkaus, kun volyymisi oikeuttaa sen. Kulutuksen seuranta itsessään ei säästä mitään suoraan – mutta se on se, joka kertoo sinulle, mitkä muista neljästä todella tuottavat hedelmää juuri sinun kontekstissasi.

Paras tapa lopettaa asiasta huolehtiminen on kapseloida nämä säännöt yhteen ainoaan pullonkaulaan. Kirjoita kääre (wrapper) funktion client.images.generate() ympärille, joka integroi kehotteiden välimuistin, automaattisen laadun ja resoluution mukauttamisen ilmoitetun käyttötarkoituksen perusteella sekä jokaisen kutsun lokittamisen; suorita se sitten kymmenelle generoinnille ja lue kulutusraportti. Siitä eteenpäin koko tiimisi säästää rahaa joutumatta muistamaan mitään.