Kosten en optimalisatie
Op deze pagina
Update 2 november 2026 — Beschikbaarheid fine-tuning. De self-service fine-tuning van OpenAI wordt gefaseerd afgebouwd: sinds 7 mei 2026 kunnen organisaties die dit nog nooit hebben gebruikt geen taken meer starten; sinds 2 juli moet u binnen de laatste 60 dagen een fine-tuned model hebben gebruikt; en vanaf 6 januari 2027 kan geen enkele klant nieuwe taken lanceren. Reeds getrainde modellen blijven bruikbaar totdat hun basismodel wordt stopgezet. Deze cursus blijft nuttig om een bestaand model te begrijpen en benutten; voor nieuwe projecten geeft u prioriteit aan prompt engineering, RAG en evaluaties.
De kostenstructuur begrijpen
Fine-tuning bij OpenAI brengt twee soorten kosten met zich mee: een eenmalige trainingskost en een terugkerende inferentiekost. Het begrijpen en optimaliseren van deze kosten is essentieel voor een winstgevende implementatie. Het onderscheid is niet louter boekhoudkundig: het eerste is een eenmalige beslissing die u neemt voordat u de taak start, en die verandert niet; het tweede volgt u elke maand en groeit met uw verkeer. Een team dat dingt over trainingskosten terwijl het een prompt van duizend tokens laat draaien op vijfduizend dagelijkse verzoeken, vecht de verkeerde strijd.
De trainingskost
Training wordt gefactureerd per verwerkt token, en dat aantal hangt rechtstreeks af van twee variabelen die u beheerst: de grootte van uw dataset en het aantal passes eroverheen.
Training cost = total_tokens × number_epochs × price_per_training_token
Met deze formule schat u de factuur voordat u iets lanceert. De volgende functie scant het JSONL-bestand en benadert het aantal tokens op basis van de berichtlengte—de schatting van één token per vier tekens in het Frans is ruw, maar volstaat om een taak van enkele dollars te onderscheiden van een taak van enkele honderden. Maak er een gewoonte van om dit systematisch uit te voeren: een voorbereidingsfout die uw dataset verdrievoudigt, springt onmiddellijk in het oog in het resultaat.
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}")
De inferentiekost
Inferentie wordt per oproep gefactureerd, op basis van input- en outputtokens, en fine-tuned modellen hebben doorgaans een iets hoger tarief dan het basismodel. Deze meerprijs per eenheid wekt vaak onterecht aarzeling: ze geldt voor veel minder tokens, aangezien het gedrag dat eerder in een lange systeemprompt werd beschreven, nu in het model is ingebouwd. De onderstaande berekening zet beide scenario’s naast elkaar voor een maand identiek verkeer, waarbij een prompt daalt van 800 naar 100 tokens tegenover verdubbelde tarieven. Pas de parameters aan met uw eigen cijfers voordat u conclusies trekt: bij gebruik waarbij de prompt al kort was, slaat de afweging om.
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}")
Inputtokens verminderen
De belangrijkste hefboom voor besparingen met een fine-tuned model is promptreductie. Elke instructie die u weet te verwijderen omdat het model deze heeft geïnternaliseerd, is een winst die bij elke oproep wordt herhaald, tot de dienst zijn levensduur bereikt. De onderstaande tabel geeft de waargenomen grootteordes weer, afhankelijk van de mate van bereikte integratie.
| 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 |
Verwijder deze instructies niet allemaal in één keer in de hoop dat alles standhoudt. Verwijder ze in groepen en voer na elke verwijdering uw testset opnieuw uit: u zult ontdekken dat sommige regels perfect zijn geleerd, terwijl andere, die minder vertegenwoordigd zijn in uw voorbeelden, in de prompt moeten blijven.
Datasetgrootte en epochs in balans brengen
Meer data levert een beter model op, maar ook hogere trainingskosten, en de opbrengsten nemen af. Van honderd naar driehonderd voorbeelden gaan, verandert meestal veel; van duizend naar drieduizend gaan, verandert weinig, voor drie keer de prijs. Train meerdere groottes, meet de behaalde kwaliteit en relateer deze aan de kosten om uw break-evenpunt te vinden.
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")
De keuze van het basismodel weegt even zwaar mee. Luna is goedkoper dan Terra, zowel voor training als voor inferentie: begin altijd met het goedkoopste model en schakel alleen over als de behaalde kwaliteit ontoereikend is. Raadpleeg de OpenAI-documentatie om te zien welke modellen in aanmerking komen voor fine-tuning—de lijst verandert met elke generatie en dekt nooit de volledige catalogus. Dan is er nog het aantal epochs, aangezien elke extra pass de trainingskost mechanisch vermenigvuldigt. Als 2 epochs 95% van de kwaliteit van 4 epochs opleveren, is de keuze snel gemaakt.
Uitgaven in productie monitoren
De schatting die voorafgaand aan de lancering wordt gemaakt, geldt alleen voor de training. In productie is het daadwerkelijke verkeer dat de kosten aanstuurt, en dat verrast vaak naar boven toe. Een teller die bij elke oproep wordt gevoed en gekoppeld is aan een maandbudget, waarschuwt u voordat de factuur dat doet. De drempel van 80% laat tijd om te reageren: verkort een prompt, beperk responslengtes of verschuif wat verkeer naar een goedkoper 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}")
De investering verantwoorden
Blijft de vraag die uw leiding vroeg of laat zal stellen: hoe lang duurt het voordat de training zichzelf terugverdient? De berekening relateert een eenmalige kost aan een maandelijkse bate, die tokensbesparingen optelt bij de waarde die u toekent aan kwaliteitswinst. Deze tweede term is het lastigst, en het is beter deze op nul te laten dan hem te verzinnen: een terugverdientijd die uitsluitend op meetbare besparingen wordt aangetoond, overtuigt meer dan een royale projectie.
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}%"
}
Belangrijkste punten
- Schat de trainingskost voordat u de taak start
- De belangrijkste hefboom voor besparingen is het verminderen van inputtokens
- Begin met het goedkoopste basismodel (Luna) voordat u opschakelt naar Terra
- Monitor kosten in productie met budgetwaarschuwingen
- Bereken de ROI inclusief kwaliteitswinst en tokensbesparingen