Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Troškovi i optimizacija

Lekcija 15 od 16 Ažurirano 2. studenoga 2026. Napredno
Na ovoj stranici
  1. Razumijevanje strukture troškova
  2. Trošak obuke
  3. Trošak zaključivanja (Inference)
  4. Smanjenje ulaznih tokena
  5. Balansiranje veličine skupa podataka i epoha
  6. Praćenje troškova u proizvodnji
  7. Opravdanje ulaganja
  8. Ključne točke

Ažuriranje 2. studenoga 2026. — Dostupnost fino podešavanja. OpenAI postupno ukida samostalno fino podešavanje: od 7. svibnja 2026. organizacije koje ga nikada nisu koristile više ne mogu stvarati zadatke; od 2. srpnja morate koristiti fino podešeni model unutar posljednjih 60 dana; a počevši od 6. siječnja 2027., nijedan korisnik neće moći pokrenuti nove zadatke. Već obučeni modeli ostaju upotrebljivi dok se njihov osnovni model ne povuče. Ovaj tečaj i dalje je koristan za razumijevanje i iskorištavanje postojećeg modela; za nove projekte dajte prednost inženjerstvu upita (prompt engineering), RAG-u i evaluacijama.

Razumijevanje strukture troškova

OpenAI fino podešavanje uključuje dvije vrste troškova: jednokratni trošak obuke i ponavljajući trošak zaključivanja (inference). Razumijevanje i optimizacija ovih troškova ključni su za isplativo uvođenje u proizvodnju. Razlika nije samo računovodstvena: prvi je jednokratna odluka donesena prije pokretanja zadatka i ona se ne mijenja; drugi vas prati svaki mjesec i raste s vašim prometom. Tim koji se nateže oko troškova obuke, a dopušta da upit od tisuću tokena teče na pet tisuća dnevnih zahtjeva, vodi bitku na pogrešnom frontu.

Trošak obuke

Obuka se naplaćuje po obrađenom tokenu, a taj broj izravno ovisi o dvije varijable koje kontrolirate: veličini vašeg skupa podataka i broju prolaza kroz njega.

Training cost = total_tokens × number_epochs × price_per_training_token

Ova formula omogućuje vam procjenu računa prije pokretanja bilo čega. Sljedeća funkcija skenira JSONL datoteku i aproksimira broj tokena na temelju duljine poruke — procjena od jednog tokena na svaka četiri znaka u hrvatskom jeziku gruba je, ali dovoljna da razlikujete zadatak od nekoliko dolara od onog koji košta nekoliko stotina. Uvedite naviku da ovo pokrećete sustavno: pogreška u pripremi koja utrostruči vaš skup podataka odmah će se pokazati u rezultatu.

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

Trošak zaključivanja (Inference)

Zaključivanje se naplaćuje po pozivu, na temelju ulaznih i izlaznih tokena, a fino podešeni modeli općenito imaju nešto višu stopu od osnovnog modela. Ova jedinična doplata često izaziva oklijevanje, pogrešno: primjenjuje se na znatno manje tokena, budući da je ponašanje prethodno opisano u dugom sistemskom upitu sada ugrađeno u model. Donji izračus stavlja oba scenarija jedan do drugoga za mjesec identičnog prometa, s upitom koji pada sa 800 na 100 tokena nasuprot udvostručenim cijenama. Prilagodite parametre svojim brojkama prije donošenja zaključaka: za uporabu gdje je upit već bio kratak, omjer se okreće.

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

Smanjenje ulaznih tokena

Glavna poluga za uštedu kod fino podešenog modela je smanjenje upita. Svaka instrukcija koju uspijete ukloniti jer ju je model internalizirao predstavlja dobitak koji se ponavlja pri svakom pozivu, sve dok usluga ne dođe do kraja životnog vijeka. Tablica u nastavku daje uočene redove veličine ovisno o stupnju postignute integracije.

Pristup Ulazni tokeni Ušteda
Osnovni model + detaljan upit 500-1000 tokena Referenca
Fino podešen + minimalan upit 50-100 tokena 80-90% na ulazu
Fino podešen + bez sistemskog upita 20-50 tokena 95% na ulazu

Nemoj uklanjati ove instrukcije odjednom nadajući se da će sve funkcionirati. Uklanjaj ih u skupinama, ponovno pokrećući svoj testni skup nakon svakog uklanjanja: otkrit ćeš da su neka pravila savršeno naučena, dok druga, manje zastupljena u tvojim primjerima, moraju ostati u upitu.

Balansiranje veličine skupa podataka i epoha

Više podataka daje bolji model, ali i veći trošak obuke, a povrat se smanjuje. Prelazak sa sto na tristo primjera obično mnogo mijenja; prelazak s tisuću na tri tisuće mijenja malo, uz trostruku cijenu. Obuci nekoliko veličina, izmjeri postignutu kvalitetu i poveži je s troškom kako bi pronašao točku pokrića.

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

Izbor osnovnog modela teži na istoj vagi. Luna je jeftinija od Tere, i za obuku i za zaključivanje: uvijek kreni s najjeftinijim modelom i prelazi na više razine samo ako je postignuta kvaliteta nedovoljna. Provjeri koji su modeli dostupni za fino podešavanje u OpenAI dokumentaciji — popis se mijenja sa svakom generacijom i nikada ne pokriva cijeli katalog. Tu je i broj epoha, jer svaki dodatni prolaz mehanički množi trošak obuke. Ako 2 epohe daju 95% kvalitete od 4 epohe, izbor je brz.

Praćenje troškova u proizvodnji

Procjena napravljena prije pokretanja vrijedi samo za obuku. U proizvodnji, stvarni promet pokreće troškove i često iznenadi naviše. Brojač napajan svakim pozivom, povezan s mjesečnim proračunom, upozorit će te prije nego što to učini račun. Prag od 80% ostavlja vrijeme za reakciju: smanji upit, ograniči duljinu odgovora ili prebaci dio prometa na jeftiniji model.

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

Opravdanje ulaganja

Ostaje pitanje koje će tvoje vodstvo prije ili kasnije postaviti: koliko će vremena trebati da se obuka isplati? Izračun povezuje jednokratni trošak s mjesečnom koristi, koja zbraja uštede tokena i vrijednost koju pridaješ dobitcima u kvaliteti. Ovaj drugi član je najteži i bolje ga je ostaviti na nuli nego ga izmišljati: povrat ulaganja dokazan isključivo na mjerljivim uštedama nosi više uvjerljivosti od velikodušne projekcije.

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

Ključne točke

  • Procijeni trošak obuke prije pokretanja zadatka
  • Glavna poluga za uštedu je smanjenje ulaznih tokena
  • Kreni s najjeftinijim osnovnim modelom (Luna) prije prelaska na Teru
  • Prati troškove u proizvodnji s upozorenjima o proračunu
  • Izračunaj ROI uključujući dobitke u kvaliteti i uštede tokena