Išlaidos ir optimizavimas
Šiame puslapyje
Atnaujinta 2026 m. lapkričio 2 d. — Derinimo prieinamumas. „OpenAI“ savitarnos derinimo paslauga yra nutraukiama: nuo 2026 m. gegužės 7 d. organizacijos, kurios jos niekada nenaudojo, nebegali kurti užduočių; nuo liepos 2 d. turite būti naudoję derintą modelį per pastaruosius 60 dienų; o nuo 2027 m. sausio 6 d. joks klientas nebegalės paleisti naujų užduočių. Jau apmokyti modeliai lieka naudojami, kol jų bazinis modelis bus nutrauktas. Šis kursas išlieka naudingas norint suprasti ir išnaudoti esamą modelį; naujiems projektams teikite pirmenybę raginimų inžinerijai (prompt engineering), RAG ir vertinimams.
Išlaidų struktūros supratimas
„OpenAI“ derinimas apima dviejų tipų išlaidas: vienkartines mokymo išlaidas ir pasikartojančias išvedimo (inference) išlaidas. Šių išlaidų supratimas ir optimizavimas yra būtinas pelningam diegimui. Skirtumas nėra tik apskaitos dalykas: pirmasis yra vienkartinis sprendimas, priimtas prieš pradedant užduotį, ir jis nekinta; antrasis jus lydi kiekvieną mėnesį ir auga kartu su jūsų srautu. Komanda, kuri derasi dėl mokymo išlaidų, bet leidžia tūkstančio tokenų raginimui veikti penkių tūkstančių kasdienių užklausų režimu, kovoja net tame fronte.
Mokymo išlaidos
Už mokymą mokama už kiekvieną apdorotą tokeną, o šis skaičius tiesiogiai priklauso nuo dviejų jūsų kontroliuojamų kintamųjų: duomenų rinkinio dydžio ir perėjimų per jį skaičiaus.
Training cost = total_tokens × number_epochs × price_per_training_token
Ši formulė leidžia įvertinti sąskaitą prieš pradedant bet kokius veiksmus. Toliau pateikta funkcija nuskenuoja JSONL failą ir apytiksliai apskaičiuoja tokenų skaičių pagal žinučių ilgį – įvertis, kad prancūzų kalbai vienas tokenas atitinka keturis simbolius, yra apytikslis, tačiau pakankamas norint atskirti kelių dolerių vertės užduotį nuo tos, kuri kainuoja šimtus. Įpraskite tai vykdyti sistemingai: parengimo klaida, kuri patrigubina jūsų duomenų rinkinį, rezultate atsiras iškart.
import json
def estimate_training_cost(
jsonl_file: str,
n_epochs: int,
price_per_million_tokens: float
) -> dict:
"""Įvertina mokymo išlaidas prieš pradedant užduotį."""
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"]:
# Apytikslis įvertis: 1 tokenas ~ 4 simboliai prancūzų k.
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 # patikrinkite dabartines kainas
)
for k, v in result.items():
print(f"{k}: {v}")
Išvedimo (Inference) išlaidos
Už išvedimą mokama už kiekvieną kvietimą, remiantis įvesties ir išvesties tokenais, o derinti modeliai paprastai turi šiek tiek didesnį įkainį nei bazinis modelis. Šis vieneto antkainis dažnai klaidingai kelia abejonių: jis taikomas daug mažiau tokenų, nes elgsena, anksčiau aprašyta ilgame sistemos raginime, dabar yra įdiegta į patį modelį. Toliau pateiktas skaičiavimas greta pateikia abu scenarijus vienam mėnesiui esant tokiam pačiam srautui, kai raginimas sumažėja nuo 800 iki 100 tokenų, o įkainiai padvigubėja. Prieš darydami išvadas, pakoreguokite parametrus savo skaičiais: tais atvejais, kai raginimas jau buvo trumpas, santykis pasikeičia priešinga kryptimi.
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:
"""Apskaičiuoja mėnesines išvedimo išlaidas."""
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
# Scenarijus: bazinis modelis su ilgu raginimu
base_cost = monthly_cost(
requests_per_day=5000,
avg_input_tokens=800, # ilgas sistemos raginimas + klausimas
avg_output_tokens=200,
price_input_per_million=0.15,
price_output_per_million=0.60
)
# Scenarijus: derintas modelis su minimaliu raginimu
ft_cost = monthly_cost(
requests_per_day=5000,
avg_input_tokens=100, # trumpas raginimas, elgsena integruota
avg_output_tokens=200,
price_input_per_million=0.30, # didesnis derinimo įkainis
price_output_per_million=1.20
)
print(f"Mėnesinė bazinė kaina: ${base_cost:.2f}")
print(f"Mėnesinė derinto modelio kaina: ${ft_cost:.2f}")
print(f"Skirtumas: ${ft_cost - base_cost:+.2f}")
Įvesties tokenų mažinimas
Pagrindinis svertas taupant naudojant derintą modelį yra raginimo sutrumpinimas. Kiekvieną instrukciją, kurią pavyksta pašalinti, nes modelis ją internalizavo, yra grynas laimėjimas, kartojamas kiekvieno kvietimo metu, kol paslauga bus nutraukta. Toliau pateiktoje lentelėje nurodytos stebimos eilės priklausomai nuo pasiekto integracijos lygio.
| Požiūris | Įvesties tokenai | Sutaupymas |
|---|---|---|
| Bazinis modelis + išsamus raginimas | 500–1000 tokenų | Etalonas |
| Derintas modelis + minimalus raginimas | 50–100 tokenų | 80–90 % įvesties |
| Derintas modelis + be sistemos raginimo | 20–50 tokenų | 95 % įvesties |
Nepašalinkite šių instrukcijų visų vienu ypu tikėdamiesi, kad viskas išsilaikys. Šalinkite jas grupėmis, po kiekvieno pašalinimo iš naujo paleisdami savo testų rinkinį: atrasite, kad kai kurios taisyklės buvo puikiai išmoktos, o kitos, mažiau atstovaujamos jūsų pavyzdžiuose, turi likti raginime.
Duomenų rinkinio dydžio ir epochų balansas
Daugiau duomenų suteikia geresnį modelį, bet taip pat didina mokymo išlaidas, o grąža mažėja. Perėjimas nuo šimto prie trijų šimtų pavyzdžių paprastai daug ką pakeičia; perėjimas nuo tūkstančio prie trijų tūkstančių keičia mažai, tačiau kainuoja trigubai daugiau. Apmokykite kelis skirtingus dydžius, išmatuokite pasiektą kokybę ir susiekite ją su išlaidomis, kad rastumėte savo lūžio tašką.
def find_optimal(results_by_size: dict):
"""Nustato optimalų duomenų rinkinio dydį."""
print("Duomenų dydis | Kokybės įvertis | Mokymo kaina")
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"\nOptimalus dydis: {optimal_size} pavyzdžių")
Bazinio modelio pasirinkimas taip pat sveria toje pačioje svarstyklėje. „Luna“ yra pigesnė nei „Terra“ tiek mokymui, tiek išvedimui: visada pradėkite nuo pigiausio modelio ir pereikite prie aukštesnio tik tada, jei pasiekta kokybė yra nepakankama. „OpenAI“ dokumentacijoje patikrinkite, kurie modeliai tinkami derinimui – sąrašas keičiasi su kiekviena karta ir niekada neapima viso katalogo. Tuomet yra epochų skaičius, nes kiekvienas papildomas perėjimas mechaniškai padidina mokymo išlaidas. Jei 2 epochos suteikia 95 % tos kokybės, kurią suteiktų 4 epochos, pasirinkimas yra greitas.
Išlaidų stebėjimas gamyboje
Prieš paleidžiant atliktas įvertis taikomas tik mokymui. Gamyboje išlaidas lemia faktinis srautas, ir jis dažnai nustebina didėjančia linkme. Skaitiklis, maitinamas kiekvieno kvietimo metu ir susietas su mėnesiniu biudžetu, įspės jus anksčiau nei sąskaita. 80 % slenkstis palieka laiko sureaguoti: sutrumpinti raginimą, apriboti atsakymų ilgį arba perkelti dalį srauto į pigesnį modelį.
class CostTracker:
"""Išlaidų stebėjimas realiuoju laiku."""
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):
"""Įrašo kvietimo išlaidas."""
cost = (
input_tokens * input_price / 1_000_000 +
output_tokens * output_price / 1_000_000
)
self.spending += cost
self.calls += 1
# Įspėjimas artėjant prie biudžeto
utilization = self.spending / self.budget * 100
if utilization > 80:
print(f"ĮSPĖJIMAS: panaudota {utilization:.1f} % mėnesinio biudžeto")
def report(self):
"""Vartojimo ataskaita."""
print(f"Kvietimai: {self.calls}")
print(f"Išlaidos: ${self.spending:.2f}")
print(f"Likęs biudžetas: ${self.budget - self.spending:.2f}")
if self.calls > 0:
print(f"Vidutinė kaina už kvietimą: ${self.spending / self.calls:.4f}")
Investicijos pagrindimas
Lieka klausimas, kurį jūsų vadovybė anksčiau ar vėliau užduos: kiek laiko prireiks, kad mokymas atsipirktų? Skaičiavimas sieja vienkartines išlaidas su mėnesine nauda, kuri apima sutaupytus tokenus ir vertę, kurią priskiriate kokybės pagerėjimui. Antrasis narys yra sudėtingiausias, ir geriau jį palikti lygų nuliui, nei išgalvoti: atsiperkamumas, pagrįstas vien tik išmatuojamais sutaupymais, įtikina labiau nei dosni projekcija.
def calculate_roi(
training_cost: float,
monthly_savings: float,
quality_gain_value: float = 0
) -> dict:
"""Apskaičiuoja derinimo investicijos grąžą."""
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} mėn.",
"annual_roi": f"{(monthly_benefit * 12 - training_cost) / training_cost * 100:.0f}%"
}
Svarbiausi punktai
- Įvertinkite mokymo išlaidas prieš pradėdami užduotį
- Pagrindinis svertas taupant yra įvesties tokenų mažinimas
- Pradėkite nuo pigiausio bazinio modelio („Luna“), prieš pereidami prie „Terra“
- Stebėkite išlaidas gamyboje naudodami biudžeto įspėjimus
- Apskaičiuokite investicijos grąžą (ROI), įtraukdami kokybės pagerėjimą ir sutaupytus tokenus