Omkostninger og optimering
På denne side
Opdatering 2. november 2026 — Tilgængelighed af finjustering. OpenAIs selvbetjente finjustering udfases: Siden 7. maj 2026 har organisationer, der aldrig har brugt tjenesten, ikke kunnet oprette nye jobs; siden 2. juli skal du have brugt en finjusteret model inden for de sidste 60 dage; og fra 6. januar 2027 vil ingen kunder kunne starte nye jobs. Allerede trænede modeller forbliver brugbare, indtil deres basismodel udgår. Dette kursus er stadig nyttigt til at forstå og udnytte en eksisterende model; til nye projekter bør du prioritere prompt engineering, RAG og evalueringer.
Forståelse af omkostningsstrukturen
OpenAI-finjustering indebærer to typer omkostninger: en engangsomkostning til træning og en løbende omkostning til inference (afledning). Det er afgørende at forstå og optimere disse omkostninger for en profitabel implementering. Skellet er ikke blot bogholderi: den første er en engangsbeslutning truffet før jobbet startes, og den ændrer sig ikke; den anden følger dig hver måned og vokser med din trafik. Et team, der prutter om træningsomkostninger, mens det lader en prompt på tusind tokens køre på fem tusind daglige forespørgsler, kæmper den forkerte kamp.
Træningsomkostningen
Træning faktureres per behandlede token, og dette tal afhænger direkte af to variabler, du styrer: størrelsen på dit datasæt og antallet af gennemløb (epochs).
Træningsomkostning = totale_tokens × antal_epochs × pris_per_træningstoken
Denne formel giver dig mulighed for at estimere regningen, før du lancerer noget. Funktionen nedenfor scanner JSONL-filen og estimerer antallet af tokens baseret på beskedlængden – estimatet på ét token per fire tegn på fransk er groft, men det er nok til at skelne et job på få dollars fra et, der koster flere hundrede. Gør det til en vane at køre dette systematisk: en forberedelsesfejl, der tredobler dit datasæt, viser sig straks i resultatet.
import json
def estimate_training_cost(
jsonl_file: str,
n_epochs: int,
price_per_million_tokens: float
) -> dict:
"""Estimerer træningsomkostninger før jobbet startes."""
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"]:
# Groft estimat: 1 token ~ 4 tegn på fransk
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 # tjek aktuelle priser
)
for k, v in result.items():
print(f"{k}: {v}")
Inference-omkostningen
Inference faktureres per kald, baseret på input- og output-tokens, og finjusterede modeller har generelt en lidt højere takst end basismodellen. Denne tillægsomkostning per enhed får ofte folk til at tøve, men det er en fejltagelse: den gælder for langt færre tokens, da adfærden, der tidligere blev beskrevet i en lang system-prompt, nu er indbygget i modellen. Beregningen nedenfor sætter begge scenarier op side om side for en måned med identisk trafik, hvor en prompt falder fra 800 til 100 tokens mod fordoblede takster. Juster parametrene med dine egne tal, før du drager konklusioner: ved brug, hvor prompten allerede var kort, vender regnestykket sig.
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:
"""Beregner månedlige inference-omkostninger."""
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
# Scenarie: Basismodel med lang prompt
base_cost = monthly_cost(
requests_per_day=5000,
avg_input_tokens=800, # lang system-prompt + spørgsmål
avg_output_tokens=200,
price_input_per_million=0.15,
price_output_per_million=0.60
)
# Scenarie: Finjusteret model med minimal prompt
ft_cost = monthly_cost(
requests_per_day=5000,
avg_input_tokens=100, # kort prompt, adfærd integreret
avg_output_tokens=200,
price_input_per_million=0.30, # højere FT-takst
price_output_per_million=1.20
)
print(f"Månedlig basisomkostning: ${base_cost:.2f}")
print(f"Månedlig finjusteret omkostning: ${ft_cost:.2f}")
print(f"Forskel: ${ft_cost - base_cost:+.2f}")
Reduktion af input-tokens
Den vigtigste løftestang til besparelser med en finjusteret model er reduktion af prompten. Hver instruktion, du formår at fjerne, fordi modellen har internaliseret den, er en gevinst, der gentages ved hvert kald, indtil tjenesten udgår. Tabellen nedenfor viser de observerede størrelsesordener afhængigt af graden af opnået integration.
| Tilgang | Input-tokens | Besparelse |
|---|---|---|
| Basismodel + detaljeret prompt | 500-1000 tokens | Reference |
| Finjusteret + minimal prompt | 50-100 tokens | 80-90% på input |
| Finjusteret + ingen system-prompt | 20-50 tokens | 95% på input |
Fjern ikke disse instruktioner alle på én gang i håb om, at alt holder. Fjern dem i grupper, og kør dit testsæt igen efter hver fjernelse: du vil opdage, at nogle regler er blevet perfekt lært, mens andre, der er mindre repræsenteret i dine eksempler, skal blive i prompten.
Afvejning af datasætstørrelse og epochs
Flere data giver en bedre model, men også højere træningsomkostninger, og afkastet aftager. At gå fra hundrede til tre hundrede eksempler ændrer normalt meget; at gå fra tusind til tre tusind ændrer lidt, til tre gange prisen. Træn flere størrelser, mål den opnåede kvalitet, og hold det op mod omkostningen for at finde dit break-even-punkt.
def find_optimal(results_by_size: dict):
"""Identificerer den optimale datasætstørrelse."""
print("Datasætstørrelse | Kvalitetsscore | Træningsomkostning")
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 størrelse: {optimal_size} eksempler")
Valget af basismodel vejer også tungt. Luna er billigere end Terra, både til træning og inference: start altid med den billigste model, og ryk kun op, hvis den opnåede kvalitet er utilstrækkelig. Tjek hvilke modeller der er berettiget til finjustering i OpenAIs dokumentation – listen ændrer sig med hver generation og dækker aldrig hele kataloget. Så er der antallet af epochs, da hvert ekstra gennemløb mekanisk ganger træningsomkostningen. Hvis 2 epochs giver 95 % af kvaliteten ved 4 epochs, er valget hurtigt truffet.
Overvågning af udgifter i produktion
Estimatet lavet før lancering gælder kun for træning. I produktionen er det den faktiske trafik, der driver omkostningerne, og det overrasker ofte opad. En tæller, der fodres ved hvert kald og er koblet til et månedligt budget, advarer dig, før regningen gør det. Grænsen på 80 % giver tid til at reagere: reducer en prompt, sæt loft over svarlængder, eller flyt noget trafik til en billigere model.
class CostTracker:
"""Omkostningssporing i realtid."""
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):
"""Registrerer omkostningen ved et kald."""
cost = (
input_tokens * input_price / 1_000_000 +
output_tokens * output_price / 1_000_000
)
self.spending += cost
self.calls += 1
# Advarsel ved nærhed til budget
utilization = self.spending / self.budget * 100
if utilization > 80:
print(f"ALARM: {utilization:.1f}% af månedligt budget brugt")
def report(self):
"""Forbrugsrapport."""
print(f"Kald: {self.calls}")
print(f"Forbrug: ${self.spending:.2f}")
print(f"Resterende budget: ${self.budget - self.spending:.2f}")
if self.calls > 0:
print(f"Gennemsnitlig omkostning per kald: ${self.spending / self.calls:.4f}")
Retfærdiggørelse af investeringen
Der er stadig det spørgsmål, som din ledelse før eller senere vil stille: hvor lang tid går der, før træningen har betalt sig selv? Beregningen relaterer en engangsomkostning til en månedlig fordel, hvilket lægger tokens-besparelser sammen med den værdi, du tillægger kvalitetsgevinster. Dette andet led er det sværeste, og det er bedre at sætte det til nul end at opfinde det: en tilbagebetalingstid demonstreret alene på målbare besparelser bærer mere overbevisning end en generøs projektion.
def calculate_roi(
training_cost: float,
monthly_savings: float,
quality_gain_value: float = 0
) -> dict:
"""Beregner afkastet på investeringen (ROI) for finjustering."""
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åneder",
"annual_roi": f"{(monthly_benefit * 12 - training_cost) / training_cost * 100:.0f}%"
}
Vigtige pointer
- Estimer træningsomkostningen før du starter jobbet
- Den vigtigste løftestang til besparelser er reduktion af input-tokens
- Start med den billigste basismodel (Luna) før du rykker op til Terra
- Overvåg omkostninger i produktion med budgetalarmer
- Beregn ROI inklusive kvalitetsgevinster og tokens-besparelser