Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Költségek és optimalizálás

15. lecke 16 közül Frissítve 2026. november 2. Haladó
Ezen az oldalon
  1. A költségszerkezet megértése
  2. A tanítási költség
  3. A következtetési költség
  4. A bemeneti tokenek csökkentése
  5. Az adathalmaz mérete és az epochok egyensúlya
  6. Költségek nyomon követése éles környezetben
  7. A befektetés indoklása
  8. Főbb megállapítások

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