Kustannukset ja optimointi
Tällä sivulla
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