Kostnader och optimering
På denna sida
Uppdatering 2 november 2026 — Tillgänglighet för finjustering. OpenAIs självbetjäningstjänst för finjustering avvecklas: sedan den 7 maj 2026 kan organisationer som aldrig använt tjänsten inte längre skapa jobb; sedan den 2 juli måste du ha använt en finjusterad modell under de senaste 60 dagarna; och från och med 6 januari 2027 kommer ingen kund att kunna starta nya jobb. Redan tränade modeller förblir användbara tills deras basmodell tas ur bruk. Denna kurs är fortfarande användbar för att förstå och utnyttja en befintlig modell; för nya projekt bör du prioritera prompt engineering, RAG och utvärderingar.
Förstå kostnadsstrukturen
Finjustering hos OpenAI innebär två typer av kostnader: en engångskostnad för träning och en återkommande kostnad för inferens. Att förstå och optimera dessa kostnader är avgörande för en lönsam drift. Skillnaden är inte bara bokföringsmässig: den första är ett engångsbeslut som fattas innan jobbet startas och som inte ändras; den andra följer dig varje månad och växer med din trafik. Ett team som prutar om träningskostnader samtidigt som det låter en prompt på tusen token köras på femtusen dagliga förfrågningar slåss mot fel fiende.
Träningskostnaden
Träning debiteras per bearbetat token, och den siffran beror direkt på två variabler du styr: storleken på din datamängd och antalet genomgångar över den.
Training cost = total_tokens × number_epochs × price_per_training_token
Denna formel låter dig uppskatta fakturan innan du startar något. Följande funktion skannar JSONL-filen och approximerar antalet token baserat på meddelandelängd – uppskattningen om ett token per fyra tecken är grov, men den räcker för att skilja ett jobb på några dollar från ett som kostar flera hundra. Gör det till en vana att köra detta systematiskt: ett förberedelsefel som tredubblar din datamängd syns omedelbart i resultatet.
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}")
Inferenskostnaden
Inferens debiteras per anrop, baserat på in- och utdatatoken, och finjusterade modeller har generellt sett en något högre taxa än basmodellen. Denna tilläggsavgift per enhet får ofta folk att tveka, vilket är felaktigt: den gäller för betydligt färre token, eftersom beteendet som tidigare beskrevs i en lång systemprompt nu är inbyggt i modellen. Beräkningen nedan ställer båda scenarierna sida vid sida för en månad med identisk trafik, där en prompt sjunker från 800 till 100 token mot fördubblade taxor. Justera parametrarna med dina egna siffror innan du drar slutsatser: för användning där prompten redan var kort, vänder sig lönsamheten.
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}")
Minska antalet inmatningstoken
Den viktigaste hävstången för besparingar med en finjusterad modell är att reducera prompten. Varje instruktion du lyckas ta bort eftersom modellen har internaliserat den är en vinst som upprepas vid varje anrop, tills tjänsten når sitt slut. Tabellen nedan visar de observerade storleksordningarna beroende på hur väl integrationen lyckats.
| Approach | Input tokens | Savings |
|---|---|---|
| Base model + detailed prompt | 500-1000 tokens | Reference |
| Fine-tuned + minimal prompt | 50-100 tokens | 80-90% on input |
| Fine-tuned + no system prompt | 20-50 tokens | 95% on input |
Ta inte bort alla dessa instruktioner på en gång i hopp om att allt ska hålla. Ta bort dem i grupper och kör om din testuppsättning efter varje borttagning: du kommer att upptäcka att vissa regler har lärt sig perfekt medan andra, som är mindre representerade i dina exempel, måste finnas kvar i prompten.
Balansera datamängdens storlek och antal epoch
Mer data ger en bättre modell, men också en högre träningskostnad, och avkastningen minskar. Att gå från hundra till trehundra exempel förändrar ofta mycket; att gå från tusen till tre tusen förändrar lite, för tre gånger priset. Träna flera storlekar, mät den uppnådda kvaliteten och relatera den till kostnaden för att hitta din break-even-punkt.
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")
Valet av basmodell väger också tungt. Luna är billigare än Terra, både för träning och inferens: börja alltid med den billigaste modellen och gå uppåt endast om den uppnådda kvaliteten är otillräcklig. Kontrollera vilka modeller som är berättigade för finjustering i OpenAIs dokumentation – listan ändras med varje generation och täcker aldrig hela katalogen. Sedan finns antalet epoch, eftersom varje ytterligare genomgång mekaniskt multiplicerar träningskostnaden. Om 2 epoch ger 95 % av kvaliteten hos 4 epoch är valet snabbt gjort.
Övervaka utgifter i produktion
Uppskattningen som gjordes innan start gäller endast för träning. I produktion är det den faktiska trafiken som driver kostnaderna, och den överraskar ofta på uppsidan. En räknare som matas vid varje anrop, kopplad till en månatlig budget, varnar dig innan fakturan gör det. Tröskeln på 80 % lämnar tid att reagera: reducera en prompt, begränsa svarslängder eller flytta viss trafik till en billigare modell.
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}")
Motivera investeringen
Återstår frågan som din ledning förr eller senare kommer att ställa: hur lång tid tar det innan träningen betalat sig? Beräkningen relaterar en engångskostnad till en månatlig nytta, vilket adderar tokenbesparingar och det värde du tillskriver kvalitetsvinster. Den andra termen är den knepigaste, och det är bättre att låta den vara noll än att hitta på något: en återbetalningstid som demonstreras enbart på mätbara besparingar bär mer övertygelse än en generös prognos.
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}%"
}
Viktiga punkter
- Uppskatta träningskostnaden innan du startar jobbet
- Den viktigaste hävstången för besparingar är att reducera antalet inmatningstoken
- Börja med den billigaste basmodellen (Luna) innan du går upp till Terra
- Övervaka kostnader i produktion med budgetvarningar
- Beräkna ROI inklusive kvalitetsvinster och tokenbesparingar