Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Kosten en optimalisatie

Les 15 van 16 Bijgewerkt op 2 november 2026 Gevorderd
Op deze pagina
  1. De kostenstructuur begrijpen
  2. De trainingskost
  3. De inferentiekost
  4. Inputtokens verminderen
  5. Datasetgrootte en epochs in balans brengen
  6. Uitgaven in productie monitoren
  7. De investering verantwoorden
  8. Belangrijkste punten

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