Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Omkostninger og optimering

Lektion 15 af 16 Opdateret 2. november 2026 Avanceret
På denne side
  1. Forståelse af omkostningsstrukturen
  2. Træningsomkostningen
  3. Inference-omkostningen
  4. Reduktion af input-tokens
  5. Afvejning af datasætstørrelse og epochs
  6. Overvågning af udgifter i produktion
  7. Retfærdiggørelse af investeringen
  8. Vigtige pointer

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