Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Kulud ja optimeerimine

Õppetund 15 / 16 Värskendatud 2. november 2026 Edasijõudnutele
Sellel lehel
  1. Kulustruktuuri mõistmine
  2. Treeningkulu
  3. Järelduskulu
  4. Sisendtokenite vähendamine
  5. Andmestiku suuruse ja epohhide tasakaalustamine
  6. Kulude jälgimine tootmises
  7. Investeeringu põhjendamine
  8. Peamised punktid

Uuendus 2. novembril 2026 — Häälestamise kättesaadavus. OpenAI iseteeninduslik häälestamine kaotatakse järk-järgult: alates 7. maist 2026 ei saa organisatsioonid, kes seda varem kasutanud pole, enam uusi ülesandeid luua; alates 2. juulist peab olema viimase 60 päeva jooksul kasutatud häälestatud mudelit; ja alates 6. jaanuarist 2027 ei saa ükski klient uusi ülesandeid käivitada. Juba treenitud mudelid jäävad kasutatavaks kuni nende baasmudeli kasutuselt kõrvaldamiseni. See kursus on endiselt kasulik olemasoleva mudeli mõistmiseks ja rakendamiseks; uute projektide puhul eelista vihjeinsenerlust (prompt engineering), RAG-i ja hindamist.

Kulustruktuuri mõistmine

OpenAI häälestamine hõlmab kahte tüüpi kulusid: ühekordne treeningkulu ja korduv järelduskulu (inference cost). Nende kulude mõistmine ja optimeerimine on kasumliku kasutuselevõtu jaoks hädavajalik. Erinevus ei seisne ainult raamatupidamises: esimene on ühekordne otsus, mis tehakse enne ülesande käivitamist ja mis ei muutu; teine saadab sind iga kuu ja kasvab koos sinu liiklusega. Meeskond, kes kaupleb treeningkulude üle, lastes samal ajal tuhande tokeni pikkusel vihjel joosta viie tuhande päevase päringu peal, võitleb vales lahingus.

Treeningkulu

Treeningu eest arvutatakse tasu töödeldud tokeni kohta ja see number sõltub otseselt kahest muutujast, mida sa kontrollid: andmestiku suurus ja selle läbimiste arv.

Training cost = total_tokens × number_epochs × price_per_training_token

See valem võimaldab sul arvet enne milleigi käivitamist hinnata. Järgnev funktsioon skannib JSONL-faili ja hindab tokenite arvu sõnumi pikkuse põhjal – hinnang ühele tokenile iga nelja prantsuse keele tähemärgi kohta on ligikaudne, kuid piisav, et eristada paari dollari suurust tööd sadu dollareid maksvast. Tee harjumuseks seda süstemaatiliselt käivitada: ettevalmistusviga, mis kolmekordistab sinu andmestiku, ilmneb tulemuses koheselt.

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}")

Järelduskulu

Järelduse eest arvutatakse tasu iga väljakutse kohta, lähtudes sisendi ja väljundi tokenitest, ning häälestatud mudelitel on üldjuhul veidi kõrgem hind kui baasmudelitel. See ühiku lisatasu põhjustab sageli kõhklemist, ja ekslikult: see kehtib palju väiksema arvu tokenite suhtes, kuna käitumine, mida varem kirjeldati pikas süsteemivihjes, on nüüd mudelisse sisse ehitatud. Allpool olev arvutus paneb mõlemad stsenaariumid kõrvuti ühe kuu identse liikluse jaoks, kus vihje pikkus langeb 800-lt 100-le tokenile vastutasuks kahekordsete hindade eest. Kohanda parameetreid oma numbritega enne järelduste tegemist: kasutusjuhtudel, kus vihje oli juba lühike, muutub tasakaal vastupidiseks.

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}")

Sisendtokenite vähendamine

Peamine hoob säästuks häälestatud mudeli kasutamisel on vihje vähendamine. Iga juhend, mille suudad eemaldada, kuna mudel on selle omaks võtnud, on võit, mis kordub iga väljakutse korral kuni teenuse elutsükli lõpuni. Allpool olev tabel toob välja vaadeldud suurusjärgud sõltuvalt saavutatud integreerituse astmest.

Lähenemine Sisendi tokenid Sääst
Baasmudel + üksikasjalik vihje 500–1000 tokenit Võrdlus
Häälestatud + minimaalne vihje 50–100 tokenit 80–90% sisendil
Häälestatud + süsteemivihjeta 20–50 tokenit 95% sisendil

Ära eemalda kõiki neid juhendeid korraga, lootes, et kõik püsib paigas. Eemalda need gruppides, käivitades pärast iga eemaldamist oma testkomplekti uuesti: avastad, et mõned reeglid on täiuslikult õpitud, samas kui teised, mis on sinu näidetes vähem esindatud, peavad vihjesse jääma.

Andmestiku suuruse ja epohhide tasakaalustamine

Rohkem andmeid annab parema mudeli, kuid toob kaasa ka suuremad treeningkulud ja tulusus väheneb. Liikumine sajalt näitelt kolmesajale muudab tavaliselt palju; liikumine tuhandelt kolmele tuhandele muudab vähe, kuid maksab kolm korda rohkem. Treeni erineva suurusega andmestikke, mõõda saavutatud kvaliteeti ja seosta see kuluga, et leida oma tasuvuspunkt.

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")

Baasmudeli valik kaalub samal kaalul. Luna on odavam kui Terra nii treeningu kui ka järelduse puhul: alusta alati odavaima mudeliga ja liigu edasi ainult siis, kui saavutatud kvaliteet on ebapiisav. Kontrolli OpenAI dokumentatsioonist, millised mudelid on häälestamiseks kõlblikud – nimekiri muutub iga põlvkonnaga ja ei hõlma kunagi kogu kataloogi. Seejärel tuleb epohhide arv, kuna iga täiendav läbimine korrutab mehaaniliselt treeningkulu. Kui 2 epohhi annavad 95% kvaliteedist võrreldes 4 epohhiga, on valik kiire.

Kulude jälgimine tootmises

Enne käivitamist tehtud hinnang kehtib ainult treeningu kohta. Tootmises määravad kulud tegelik liiklus ja see üllatab sageli suuremas suunas. Igal väljakutsel toituv loendur, mis on seotud kuu eelarvega, hoiatab sind enne arvet. 80% lävend jätab aega reageerimiseks: vähenda vihjet, piira vastuste pikkust või suuna osa liiklusest odavamale mudelile.

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}")

Investeeringu põhjendamine

Jääb veel küsimus, mida sinu juhtkond varem või hiljem esitab: kui kaua kulub, kuni treening end ära tasub? Arvutus seob ühekordse kulu igakuise kasuga, mis liidab kokku tokenite säästu ja väärtuse, mille omistad kvaliteedi tõusule. See teine liige on kõige keerulisem ja parem on jätta see nulliks, kui seda välja mõelda: tasuvusaeg, mis on demonstreeritud ainult mõõdetava säästu põhjal, veenab rohkem kui helde prognoos.

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}%"
    }

Peamised punktid

  • Hinda treeningkulu enne ülesande käivitamist
  • Peamine hoob säästuks on sisendtokenite vähendamine
  • Alusta odavaima baasmudeliga (Luna) enne Terra-le üleminekut
  • Jälgi kulusid tootmises eelarvehoiatuste abil
  • Arvuta investeeringutasuvus (ROI), kaasates kvaliteedi tõusu ja tokenite säästu