Stroški in optimizacija
Na tej strani
Posodobitev 2. novembra 2026 — Razpoložljivost prilagajanja. Samostojno prilagajanje (fine-tuning) podjetja OpenAI se postopno ukinja: organizacije, ki ga še niso uporabljale, od 7. maja 2026 ne morejo več ustvarjati opravil; od 2. julija morate prilagojen model uporabiti v zadnjih 60 dneh; in od 6. januarja 2027 noben uporabnik ne bo mogel zagnati novih opravil. Že usposobljeni modeli ostanejo uporabni, dokler njihov osnovni model ni umaknjen. Ta tečaj je še vedno koristen za razumevanje in izkoriščanje obstoječega modela; za nove projekte dajte prednost inženiringu pozivov, RAG in evalvacijam.
Razumevanje strukture stroškov
Prilagajanje modelov OpenAI vključuje dve vrsti stroškov: enkratni strošek usposabljanja in ponavljajoči se strošek sklepanja (inference). Razumevanje in optimizacija teh stroškov sta ključna za dobičkonosno uvedbo. Razlika ni le računovodska: prvi je enkratna odločitev, sprejeta pred zagonom opravila, ki se ne spremeni; drugi vas spremlja vsak mesec in raste z vašim prometom. Ekipa, ki se prepira o stroških usposabljanja, medtem ko dopušča delovanje poziva z tisoč žetoni pri petih tisoč dnevnih zahtevah, se bori v napačni bitki.
Strošek usposabljanja
Usposabljanje se zaračuna na žeton, ta številka pa je neposredno odvisna od dveh spremenljivk, ki ju nadzorujete: velikosti vašega nabora podatkov in števila prehodov skozi njega.
Strošek usposabljanja = skupno_število_žetonov × število_epoh × cena_na_žeton_usposabljanja
Ta formula vam omogoča oceno računa pred zagonom česar koli. Naslednja funkcija pregleda datoteko JSONL in približno oceni število žetonov na podlagi dolžine sporočil – ocena enega žetona na štiri znake v slovenščini je groba, a zadostuje za razlikovanje med opravilom, ki stane nekaj dolarjev, in tistim, ki stane več sto. Navadite se, da to izvajate sistematično: napaka pri pripravi, ki potroji vaš nabor podatkov, se takoj pokaže v rezultatu.
import json
def estimate_training_cost(
jsonl_file: str,
n_epochs: int,
price_per_million_tokens: float
) -> dict:
"""Oceni strošek usposabljanja pred zagonom opravila."""
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"]:
# Groba ocena: 1 žeton ~ 4 znaki v slovenščini
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 # preveri trenutne cene
)
for k, v in result.items():
print(f"{k}: {v}")
Strošek sklepanja (Inference)
Sklepanje se zaračuna na klic, na podlagi vhodnih in izhodnih žetonov, prilagojeni modeli pa imajo običajno nekoliko višjo stopnjo kot osnovni model. Ta dodatna enotna pristojbina pogosto povzroči oklevanje, a napačno: uporablja se za bistveno manj žetonov, saj je vedenje, ki je bilo prej opisano v dolgem sistemskem pozivu, zdaj vgrajeno v model. Spodnji izračun postavlja oba scenarija drug ob drugega za mesec enakomernega prometa, pri čemer se poziv zmanjša s 800 na 100 žetonov ob podvojenih cenah. Prilagodi parametre s svojimi številkami, preden potegneš zaključke: pri uporabi, kjer je bil poziv že kratek, se razmerje obrne.
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:
"""Izračuna mesečni strošek sklepanja."""
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
# Scenarij: osnovni model z dolgim pozivom
base_cost = monthly_cost(
requests_per_day=5000,
avg_input_tokens=800, # dolg sistemski poziv + vprašanje
avg_output_tokens=200,
price_input_per_million=0.15,
price_output_per_million=0.60
)
# Scenarij: prilagojen model z minimalnim pozivom
ft_cost = monthly_cost(
requests_per_day=5000,
avg_input_tokens=100, # kratek poziv, vedenje integrirano
avg_output_tokens=200,
price_input_per_million=0.30, # višja cena za FT
price_output_per_million=1.20
)
print(f"Mesečni strošek osnove: ${base_cost:.2f}")
print(f"Mesečni strošek prilagojenega: ${ft_cost:.2f}")
print(f"Razlika: ${ft_cost - base_cost:+.2f}")
Zmanjševanje vhodnih žetonov
Glavni vzvod za prihranke pri prilagojenem modelu je zmanjšanje poziva. Vsako navodilo, ki ga uspeš odstraniti, ker ga je model internaliziral, predstavlja dobiček, ki se ponovi pri vsakem klicu, vse dokler storitev ne preneha delovati. Spodnja tabela prikazuje opažene red velikosti glede na stopnjo dosežene integracije.
| Pristop | Vhodni žetoni | Prihranki |
|---|---|---|
| Osnovni model + podroben poziv | 500–1000 žetonov | Referenca |
| Prilagojen + minimalen poziv | 50–100 žetonov | 80–90 % pri vhodu |
| Prilagojen + brez sistemskega poziva | 20–50 žetonov | 95 % pri vhodu |
Teh navodil ne odstranjuj vsega naenkrat v upanju, da bo vse držalo. Odstranjuj jih v skupinah in po vsakem odstranjevanju ponovno zaženi svoj testni nabor: odkril boš, da so bila nekatera pravila popolnoma usvojena, medtem ko morajo druga, manj zastopana v tvojih primerih, ostati v pozivu.
Uravnoteženje velikosti nabora podatkov in epoh
Več podatkov pomeni boljši model, a tudi višji strošek usposabljanja, donosnost pa upada. Prehod s sto na tristo primerov običajno veliko spremeni; prehod s tisoč na tri tisoč spremeni malo, ob trikratni ceni. Usposobi več velikosti, izmeri doseženo kakovost in jo poveži s stroškom, da najdeš svojo točko preloma.
def find_optimal(results_by_size: dict):
"""Identificira optimalno velikost nabora podatkov."""
print("Velikost nabora | Ocena kakovosti | Strošek usposabljanja")
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"\nOptimalna velikost: {optimal_size} primerov")
Izbira osnovnega modela tehta na isti tehtnici. Luna je cenejša od Terre, tako za usposabljanje kot za sklepanje: vedno začni z najcenejšim modelom in napreduj le, če je dosežena kakovost nezadostna. Preveri, kateri modeli so primerni za prilagajanje v dokumentaciji OpenAI – seznam se spreminja z vsako generacijo in nikoli ne zajema celotnega kataloga. Tu je še število epoh, saj vsak dodatni prehod mehansko pomnoži strošek usposabljanja. Če 2 epohi zagotovita 95 % kakovosti 4 epoh, je izbira hitra.
Spremljanje porabe v proizvodnji
Ocena, opravljena pred zagonom, velja le za usposabljanje. V proizvodnji so tisti, ki poganjajo stroške, dejanski promet, ki pogosto preseneti navzgor. Števec, ki se napaja ob vsakem klicu in je povezan z mesečnim proračunom, te opozori, preden to stori račun. Prag 80 % pusti čas za reakcijo: zmanjšaj poziv, omeji dolžine odgovorov ali preusmeri del prometa na cenejši model.
class CostTracker:
"""Sledenje stroškom v realnem času."""
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):
"""Zabeleži strošek klica."""
cost = (
input_tokens * input_price / 1_000_000 +
output_tokens * output_price / 1_000_000
)
self.spending += cost
self.calls += 1
# Opozorilo ob približevanju proračunu
utilization = self.spending / self.budget * 100
if utilization > 80:
print(f"OPOZORILO: Porabljenih {utilization:.1f} % mesečnega proračuna")
def report(self):
"""Poročilo o porabi."""
print(f"Klici: {self.calls}")
print(f"Poraba: ${self.spending:.2f}")
print(f"Preostali proračun: ${self.budget - self.spending:.2f}")
if self.calls > 0:
print(f"Povprečni strošek na klic: ${self.spending / self.calls:.4f}")
Utemeljitev naložbe
Ostaja še vprašanje, ki ga bo tvoje vodstvo prej ali slej postavilo: kako dolgo bo trajalo, da se usposabljanje samo povrne? Izračun povezuje enkratni strošek z mesečno koristjo, ki sešteva prihranke žetonov in vrednost, ki jo pripisuješ dobičkom v kakovosti. Ta drugi člen je najtežji in bolje ga je pustiti na ničli, kot pa si ga izmišljati: donosnost, dokazana zgolj na merljivih prihrankih, prepriča bolj kot velikodušna projekcija.
def calculate_roi(
training_cost: float,
monthly_savings: float,
quality_gain_value: float = 0
) -> dict:
"""Izračuna donosnost naložbe za prilagajanje."""
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 ugotovitve
- Pred zagonom opravila oceni strošek usposabljanja
- Glavni vzvod za prihranke je zmanjšanje vhodnih žetonov
- Začni z najcenejšim osnovnim modelom (Luna), preden preideš na Tero
- Spremljaj stroške v proizvodnji z opozorili o proračunu
- Izračunaj ROI, vključno z dobički v kakovosti in prihranki žetonov