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

Kustannukset ja optimointi

Oppitunti 15 / 16 Päivitetty 2. marraskuuta 2026 Edistynyt
Tällä sivulla
  1. Kustannusrakenteen ymmärtäminen
  2. Koulutuskustannus
  3. Päättelykustannus (Inference)
  4. Input-tokenien vähentäminen
  5. Tietoaineiston koon ja epochien tasapainottaminen
  6. Kulujen seuranta tuotannossa
  7. Investoinnin oikeuttaminen
  8. Keskeiset asiat

Päivitys 2. marraskuuta 2026 — Hienosäädön saatavuus. OpenAI:n itsepalveluhienosäätö on poistumassa: 7. toukokuuta 2026 lähtien organisaatiot, jotka eivät ole koskaan käyttäneet sitä, eivät voi enää luoda tehtäviä; 2. heinäkuuta lähtien sinun on täytynyt käyttää hienosäädettyä mallia viimeisen 60 päivän aikana; ja 6. tammikuuta 2027 alkaen mikään asiakas ei voi käynnistää uusia tehtäviä. Jo koulutetut mallit pysyvät käytössä, kunnes niiden perusmalli poistetaan käytöstä. Tämä kurssi on edelleen hyödyllinen olemassa olevan mallin ymmärtämiseen ja hyödyntämiseen; uusissa projekteissa priorisoi kehotetekniikkaa (prompt engineering), RAG:ia ja arviointeja.

Kustannusrakenteen ymmärtäminen

OpenAI-hienosäätöön liittyy kahdenlaisia kustannuksia: kertaluonteinen koulutuskustannus ja toistuva päättelykustannus (inference). Näiden kustannusten ymmärtäminen ja optimointi on välttämätöntä kannattavalle käyttöönotolle. Ero ei ole vain kirjanpidollinen: ensimmäinen on kertaluonteinen päätös, joka tehdään ennen tehtävän käynnistämistä, eikä se muutu; toinen seuraa sinua joka kuukausi ja kasvaa liikenteesi myötä. Tiimi, joka tingii koulutuskustannuksista samalla kun antaa tuhannen tokenin kehotteen pyöriä viidellätuhannella päivittäisellä pyynnöllä, taistelee väärää taistelua.

Koulutuskustannus

Koulutuksesta laskutetaan käsiteltyä tokenia kohden, ja tämä luku riippuu suoraan kahdesta muuttujasta, joita hallitset: tietoainesi koosta ja sen läpikertojen määrästä.

Training cost = total_tokens × number_epochs × price_per_training_token

Tämän kaavan avulla voit arvioida laskun ennen minkään käynnistämistä. Seuraava funktio skannaa JSONL-tiedoston ja arvioi tokenien määrän viestin pituuden perusteella – arvio yhdestä tokenista neljää merkkiä kohden ranskaksi on karkea, mutta se riittää erottamaan muutaman dollarin tehtävän useiden satojen dollarien tehtävästä. Tee tavaksi suorittaa tämä järjestelmällisesti: valmisteluvirhe, joka kolminkertaistaa tietoaineesi, näkyy välittömästi tuloksessa.

import json

def estimate_training_cost(
    jsonl_file: str,
    n_epochs: int,
    price_per_million_tokens: float
) -> dict:
    """Estimates training cost before launching the job."""
    total_tokens = 0

    with open(jsonl_file, "r") as f:
        num_examples = 0
        for line in f:
            num_examples += 1
            obj = json.loads(line)
            for msg in obj["messages"]:
                # Rough estimate: 1 token ~ 4 characters in French
                total_tokens += len(msg["content"]) // 4

    training_tokens = total_tokens * n_epochs
    cost = training_tokens * price_per_million_tokens / 1_000_000

    return {
        "examples": num_examples,
        "tokens_per_pass": total_tokens,
        "epochs": n_epochs,
        "total_tokens": training_tokens,
        "estimated_cost": f"${cost:.2f}"
    }

result = estimate_training_cost(
    "training_data.jsonl",
    n_epochs=3,
    price_per_million_tokens=8.0  # check current pricing
)

for k, v in result.items():
    print(f"{k}: {v}")

Päättelykustannus (Inference)

Päättelystä laskutetaan kutakin kutsua kohden input- ja output-tokenien perusteella, ja hienosäädetyillä malleilla on yleensä hieman korkeampi hinta kuin perusmalleilla. Tämä yksikkölisämaksu aiheuttaa usein epäröintiä, virheellisesti: se koskee paljon harvempia tokeneita, sillä malliin on nyt rakennettu käyttäytyminen, joka aiemmin kuvattiin pitkässä järjestelmäkehotteessa. Alla oleva laskelma asettaa molemmat skenaariot rinnakkain kuukauden identtiselle liikenteelle, kun kehote putoaa 800 tokenista 100:aan hintojen kaksinkertaistuessa. Säädä parametrit omilla luvuillasi ennen johtopäätösten tekemistä: käytössä, jossa kehote oli jo lyhyt, kompromissi kääntyy päinvastaiseksi.

def monthly_cost(
    requests_per_day: int,
    avg_input_tokens: int,
    avg_output_tokens: int,
    price_input_per_million: float,
    price_output_per_million: float
) -> float:
    """Calculates monthly inference cost."""
    requests_month = requests_per_day * 30
    input_cost = requests_month * avg_input_tokens * price_input_per_million / 1_000_000
    output_cost = requests_month * avg_output_tokens * price_output_per_million / 1_000_000
    return input_cost + output_cost

# Scenario: base model with long prompt
base_cost = monthly_cost(
    requests_per_day=5000,
    avg_input_tokens=800,    # long system prompt + question
    avg_output_tokens=200,
    price_input_per_million=0.15,
    price_output_per_million=0.60
)

# Scenario: fine-tuned model with minimal prompt
ft_cost = monthly_cost(
    requests_per_day=5000,
    avg_input_tokens=100,    # short prompt, behavior integrated
    avg_output_tokens=200,
    price_input_per_million=0.30,  # higher FT rate
    price_output_per_million=1.20
)

print(f"Monthly base cost: ${base_cost:.2f}")
print(f"Monthly fine-tuned cost: ${ft_cost:.2f}")
print(f"Difference: ${ft_cost - base_cost:+.2f}")

Input-tokenien vähentäminen

Tärkein vipu säästöihin hienosäädetyn mallin kanssa on kehotteen lyhentäminen. Jokainen ohje, jonka onnistut poistamaan, koska malli on omaksunut sen, on voitto, joka toistuu jokaisessa kutsussa, kunnes palvelu saavuttaa elinkaarensa pään. Alla oleva taulukko antaa havaitut suuruusluokat saavutetun integraatioasteen mukaan.

Lähestymistapa Input-tokenit Säästöt
Perusmalli + yksityiskohtainen kehote 500–1000 tokenia Vertailukohta
Hienosäädetty + minimaalinen kehote 50–100 tokenia 80–90 % inputissa
Hienosäädetty + ei järjestelmäkehotetta 20–50 tokenia 95 % inputissa

Älä poista näitä ohjeita kerralla toivoen, että kaikki pysyy kasassa. Poista ne ryhmissä ja suorita testijoukkosi uudelleen jokaisen poiston jälkeen: huomaat, että jotkin säännöt on opittu täydellisesti, kun taas toiset, jotka ovat vähemmän edustettuina esimerkeissäsi, on pidettävä kehotteessa.

Tietoaineiston koon ja epochien tasapainottaminen

Enemmän dataa antaa paremman mallin, mutta myös korkeamman koulutuskustannuksen, ja tuotto heikkenee. Siirtyminen sadasta esimerkkiin kolmeensataan muuttaa yleensä paljon; siirtyminen tuhannesta kolmeentuhanteen muuttaa vähän, mutta hinta on kolminkertainen. Kouluta useita kokoja, mittaa saavutettu laatu ja suhteuta se kustannuksiin löytääksesi kannattavuuspisteesi.

def find_optimal(results_by_size: dict):
    """Identifies the optimal dataset size."""
    print("Dataset size | Quality score | Training cost")
    print("-" * 55)

    best_ratio = 0
    optimal_size = 0

    for size, data in sorted(results_by_size.items()):
        score = data["score"]
        cost = data["cost"]
        ratio = score / cost if cost > 0 else 0

        print(f"{size:>14} | {score:>13.2f} | {cost:>17.2f} $")

        if ratio > best_ratio:
            best_ratio = ratio
            optimal_size = size

    print(f"\nOptimal size: {optimal_size} examples")

Perusmallin valinta vaikuttaa samaan vaakakuppiin. Luna on halvempi kuin Terra sekä koulutuksessa että päättelyssä: aloita aina halvimmasta mallista ja siirry ylöspäin vain, jos saavutettu laatu on riittämätön. Tarkista OpenAI:n dokumentaatiosta, mitkä mallit ovat hienosäädön piirissä – lista muuttuu jokaisen sukupolven myötä eikä kata koskaan koko luetteloa. Sitten on epochien määrä, sillä jokainen lisäläpikerta kertoo mekaanisesti koulutuskustannuksen. Jos 2 epochia antaa 95 % laadusta verrattuna 4 epochiin, valinta on nopea.

Kulujen seuranta tuotannossa

Ennen käynnistystä tehty arvio koskee vain koulutusta. Tuotannossa todellinen liikenne ajaa kustannuksia, ja se yllättää usein noususuunnassa. Jokaisessa kutsussa syötetty laskuri, joka on sidottu kuukausibudjettiin, hälyttää ennen laskua. 80 %:n kynnys jättää aikaa reagoida: lyhennä kehotetta, rajoita vastausten pituutta tai siirrä osa liikenteestä halvempaan malliin.

class CostTracker:
    """Real-time cost tracking."""

    def __init__(self, monthly_budget: float):
        self.budget = monthly_budget
        self.spending = 0.0
        self.calls = 0

    def record(self, input_tokens: int, output_tokens: int,
               input_price: float, output_price: float):
        """Records the cost of a call."""
        cost = (
            input_tokens * input_price / 1_000_000 +
            output_tokens * output_price / 1_000_000
        )
        self.spending += cost
        self.calls += 1

        # Alert if approaching budget
        utilization = self.spending / self.budget * 100
        if utilization > 80:
            print(f"ALERT: {utilization:.1f}% of monthly budget used")

    def report(self):
        """Consumption report."""
        print(f"Calls: {self.calls}")
        print(f"Spending: ${self.spending:.2f}")
        print(f"Remaining budget: ${self.budget - self.spending:.2f}")
        if self.calls > 0:
            print(f"Average cost per call: ${self.spending / self.calls:.4f}")

Investoinnin oikeuttaminen

Jäljelle jää kysymys, jonka johtosi esittää ennemmin tai myöhemmin: kuinka kauan kestää, ennen kuin koulutus maksaa itsensä takaisin? Laskelma yhdistää kertaluonteisen kustannuksen kuukausittaiseen hyötyyn, joka sisältää tokenisäästöt ja laadunparannuksille antamasi arvon. Tämä jälkimmäinen termi on hankalin, ja on parempi jättää se nollaksi kuin keksiä sitä: takaisinmaksuaika, joka perustuu vain mitattaviin säästöihin, vakuuttaa enemmän kuin antelias projekti.

def calculate_roi(
    training_cost: float,
    monthly_savings: float,
    quality_gain_value: float = 0
) -> dict:
    """Calculates the return on investment for fine-tuning."""
    monthly_benefit = monthly_savings + quality_gain_value
    payback_months = training_cost / monthly_benefit if monthly_benefit > 0 else float("inf")

    return {
        "training_cost": f"${training_cost:.2f}",
        "monthly_benefit": f"${monthly_benefit:.2f}",
        "payback": f"{payback_months:.1f} months",
        "annual_roi": f"{(monthly_benefit * 12 - training_cost) / training_cost * 100:.0f}%"
    }

Keskeiset asiat

  • Arvioi koulutuskustannus ennen tehtävän käynnistämistä
  • Tärkein vipu säästöihin on input-tokenien vähentäminen
  • Aloita halvimmasta perusmallista (Luna) ennen siirtymistä malliin Terra
  • Seuraa kustannuksia tuotannossa budjettihälytyksillä
  • Laske ROI mukaan lukien laadunparannukset ja tokenisäästöt