Költségek és optimalizálás
Ezen az oldalon
Frissítés: 2026. november 2. — Fine-tuning elérhetőség. Az OpenAI saját kiszolgálású fine-tuning szolgáltatását fokozatosan megszüntetik: 2026. május 7. óta azok a szervezetek, amelyek még sosem használták, már nem hozhatnak létre feladatokat; július 2. óta az elmúlt 60 napban használnod kellett egy finomhangolt modellt; és 2027. január 6-tól egyetlen ügyfél sem indíthat új feladatokat. A már betanított modellek addig használhatók maradnak, amíg az alapmodelljüket nyugdíjba nem vonják. Ez a tanfolyam továbbra is hasznos egy meglévő modell megértéséhez és kiaknázásához; új projektek esetén előnyben részesítsd a prompt mérnökséget, a RAG-ot és az értékeléseket.
A költségszerkezet megértése
Az OpenAI fine-tuning kétféle költséggel jár: egy egyszeri tanítási költséggel és egy ismétlődő következtetési (inference) költséggel. Ezen költségek megértése és optimalizálása elengedhetetlen a nyereséges üzemeltetéshez. A különbségtétel nem csupán könyvelési kérdés: az első egy egyszeri döntés, amelyet a feladat indítása előtt hozol meg, és ez nem változik; a második minden hónapban kísér, és a forgalmaddal együtt növekszik. Az a csapat, amely alkudozik a tanítási költségeken, miközben hagyja, hogy egy ezer tokenes prompt lefusson napi ötezer kérésen, rossz csatát vív.
A tanítási költség
A tanításért feldolgozott tokenenként számítanak fel díjat, és ez a szám közvetlenül két általad kontrollált változótól függ: az adathalmazod méretétől és az azon végzett menetek (epoch) számától.
Training cost = total_tokens × number_epochs × price_per_training_token
Ez a képlet lehetővé teszi, hogy bármi indítása előtt megbecsüld a számlát. Az alábbi függvény beolvassa a JSONL fájlt, és az üzenetek hossza alapján közelíti a tokenszámot – a franciára vonatkozó „egy token ~ négy karakter“ becslés durva, de elég ahhoz, hogy megkülönböztesd a néhány dolláros feladatot a több százba kerülőtől. Szoktasd rá magad, hogy ezt szisztematikusan lefuttasd: egy előkészítési hiba, amely megháromszorozza az adathalmazodat, azonnal megjelenik az eredményben.
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}")
A következtetési költség
A következtetésért hívásonként számítanak fel díjat, a bemeneti és kimeneti tokenek alapján, és a finomhangolt modellek általában valamivel magasabb díjszabással rendelkeznek, mint az alapmodellek. Ez az egységnyi felár gyakran okoz habozást, tévesen: sokkal kevesebb tokenre vonatkozik, mivel a korábban hosszú rendszerpromptban leírt viselkedés most beépült a modellbe. Az alábbi számítás egymás mellé állítja mindkét forgatókönyvet egy hónap azonos forgalma mellett, ahol a prompt 800 tokenről 100-ra csökken a megduplázódott díjak ellenére. Mielőtt levonnád a következtetéseket, igazítsd a paramétereket a saját számaidhoz: olyan használat esetén, ahol a prompt már eleve rövid volt, a mérleg nyelve ellenkező irányba billen.
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}")
A bemeneti tokenek csökkentése
A finomhangolt modellel elérhető megtakarítás fő eszköze a prompt csökkentése. Minden egyes utasítás, amelyet sikerül eltávolítanod, mert a modell internalizálta azt, nyereséget jelent, amely minden hívásnál megismétlődik, egészen addig, amíg a szolgáltatás meg nem szűnik. Az alábbi táblázat a megfigyelt nagyságrendeket mutatja az elért integráció mértékétől függően.
| Megközelítés | Bemeneti tokenek | Megtakarítás |
|---|---|---|
| Alapmodell + részletes prompt | 500-1000 token | Referencia |
| Finomhangolt + minimális prompt | 50-100 token | 80-90% a bemeneten |
| Finomhangolt + rendszerprompt nélkül | 20-50 token | 95% a bemeneten |
Ne távolítsd el ezeket az utasításokat egyszerre abban a reményben, hogy minden működni fog. Csoportosan távolítsd el őket, és minden egyes eltávolítás után futtasd újra a tesztkészletedet: rájössz majd, hogy egyes szabályokat tökéletesen megtanult a modell, míg másokat, amelyek kevésbé voltak reprezentáltak a példáidban, bent kell hagynod a promptban.
Az adathalmaz mérete és az epochok egyensúlya
Több adat jobb modellt eredményez, de magasabb tanítási költséggel is jár, és a hozamok csökkennek. Ha száz példáról háromszázra térsz át, az általában sokat változtat; ha ezerről háromezerre, az keveset változtat, háromszoros árért. Taníts több különböző méretet, mérd meg az elért minőséget, és viszonyítsd a költségekhez, hogy megtaláld a megtérülési pontodat.
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")
Az alapmodell megválasztása is ugyanerre a mérlegre kerül. A Luna olcsóbb, mint a Terra, mind a tanítás, mind a következtetés szempontjából: mindig a legolcsóbb modellel kezdj, és csak akkor lépj feljebb, ha az elért minőség elégtelen. Ellenőrizd az OpenAI dokumentációjában, hogy mely modellek alkalmasak fine-tuningra – a lista generációnként változik, és sosem fedi le a teljes katalógust. Aztán ott van az epochok száma, mivel minden egyes további menet mechanikusan megszorozza a tanítási költséget. Ha 2 epoch a 4 epoch minőségének 95%-át adja, a választás gyors.
Költségek nyomon követése éles környezetben
Az indítás előtt készített becslés csak a tanításra vonatkozik. Éles környezetben a tényleges forgalom hajtja a költségeket, és ez gyakran okoz kellemetlen meglepetést felfelé. Egy minden hívásnál frissülő számláló, amely hozzá van kötve egy havi költségkerethez, figyelmeztet, mielőtt a számla megérkezne. A 80%-os küszöbérték időt hagy a reagálásra: csökkentsd a promptot, korlátozd a válaszok hosszát, vagy irányítsd át a forgalom egy részét egy olcsóbb modellre.
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}")
A befektetés indoklása
Marad még egy kérdés, amelyet a vezetőséged előbb-utóbb feltesz: mennyi idő alatt térül meg a tanítás? A számítás egy egyszeri költséget viszonyít egy havi haszonhoz, amely magában foglalja a token-megtakarítást és a minőségjavulásnak tulajdonított értéket. Ez utóbbi tag a legtrükkösebb, és jobb nullának hagyni, mint kitalálni: egy csak mérhető megtakarításokon alapuló megtérülés meggyőzőbb, mint egy nagylelkű vetítés.
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}%"
}
Főbb megállapítások
- Becsüld meg a tanítási költséget a feladat indítása előtt
- A megtakarítás fő eszköze a bemeneti tokenek csökkentése
- Kezd a legolcsóbb alapmodellel (Luna), mielőtt a Terrára váltanál
- Kövesd nyomon a költségeket éles környezetben költségkeret-riasztásokkal
- Számold ki a ROI-t a minőségjavulás és a token-megtakarítás figyelembevételével