Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Forudsagte output: Hurtigere svar

Lektion 4 af 20 Opdateret 3. november 2026 Avanceret
På denne side
  1. Gør svar hurtigere, når du allerede kender strukturen
  2. Valideringsmekanismen
  3. Beslut automatisk
  4. Vigtige pointer

Lektionen opdateret 3. november 2026 baseret på guiden Predicted Outputs og OpenAIs side om udfasninger: Denne funktion findes kun i Chat Completions (parameteren prediction accepteres ikke af Responses API, så den tidligere version af denne lektion ville have fejlet) og kun med modellerne GPT-4o, GPT-4o mini, GPT-4.1 og GPT-4.1 mini, som OpenAI vil udfase den 14. januar 2027 (GPT-4.1 nano blev udfaset den 23. oktober). Guiden nævner ingen nyere kompatible modeller: Byg ikke nye produkter på denne funktion uden en exit-strategi. Kilder: Predicted Outputs · Deprecations.

Gør svar hurtigere, når du allerede kender strukturen

Forudsagte output løser et meget almindeligt produktionsscenarie: Du beder modellen om at ændre eksisterende indhold, og du ved på forhånd, at størstedelen af resultatet vil være identisk med inputtet. Uden forudsigelse regenererer modellen hvert eneste token fra bunden, inklusive linjer, som ingen har bedt den om at røre ved. Med forudsigelse leverer du den forventede tekst; modellen validerer det, der matcher, og genererer kun genuint de dele, der adskiller sig. Latensen falder tilsvarende.

Dette skift ændrer især profilen for redigeringsopgaver. En assistent, der omskriver en fil på to hundrede linjer for at ændre en funktions-signatur, betaler ikke længere for at generere hele filen, men kun for de berørte linjer: Det meste af arbejdet reduceres til en sammenligning. De relevante tilfælde ligner alle hinanden: Kode-redigering, hvor du sender hele filen for en målrettet ændring; delvis omskrivning, hvor kun et enkelt afsnit i et langt dokument skal formuleres om; skabelon-udfyldning, hvor kun variabel-felter ændres; og opdatering af strukturerede data, hvor to eller tre værdier i en JSON udvikler sig, mens resten af strukturen forbliver. I hvert af disse tilfælde eksisterer det forventede svar allerede med kun mindre forskelle.

Et eksempel på kode-redigering

Kaldet bygges som et standard Chat Completions-kald, udvidet med en prediction-parameter, der bærer det indhold, du forventer.

import openai

client = openai.OpenAI()

code_original = """
def calculate_price(quantity, unit_price, vat=0.20):
    subtotal = quantity * unit_price
    total = subtotal * (1 + vat)
    return total

def format_invoice(client, items):
    lines = []
    for item in items:
        price = calculate_price(item["qty"], item["price"])
        lines.append(f"{item['name']}: {price:.2f}€")
    return "\n".join(lines)
"""

# Vi forudsiger, at det meste af koden forbliver identisk
instruction = (
    "Modify the calculate_price function to add a discount parameter "
    "with a default value of 0. Apply the discount before VAT. "
    "Respond with code only."
)

completion = client.chat.completions.create(
    model="gpt-4.1",
    messages=[
        {"role": "user", "content": instruction},
        {"role": "user", "content": code_original},
    ],
    prediction={
        "type": "content",
        "content": code_original,  # Forudsigelsen
    },
)

print(completion.choices[0].message.content)
# Modellen regenererer kun de modificerede linjer — reduceret latens

Funktionen format_invoice påvirkes ikke af anmodningen: Den vil blive valideret, som den er, uden omkostninger til generering. Kun linjerne i calculate_price, der rummer den nye parameter, vil blive produceret genuint.

Valideringsmekanismen

At forstå, hvad der sker under motorhjellet, undgår to almindelige misforståelser. Modellen sammenligner sin egen generering, token for token, med den forudsigelse, du har leveret; så længe de to matcher, valideres tokens øjeblikkeligt, hvilket omgår den fulde beregning for generering. Så snart de divergerer, overtager normal generering. Det endelige resultat forbliver derfor korrekt: Forudsigelse gør tingene hurtigere, den tvinger ikke noget igennem. Hvis din forudsigelse er forkert, får du stadig det rigtige svar, blot uden gevinsten.

Den anden misforståelse angår prisen. Afviste forudsigelses-tokens faktureres, hvilket gør operationen kontraproduktiv, når det forventede svar intet har at gøre med forudsigelsen. Mål derfor accept-raten, før du generaliserer mønsteret.

completion = client.chat.completions.create(
    model="gpt-4.1",
    messages=[
        {"role": "user", "content": "Add a discount parameter to the calculate_price function."},
        {"role": "user", "content": code_original},
    ],
    prediction={
        "type": "content",
        "content": code_original,
    },
)

usage = completion.usage
print(f"Output tokens: {usage.completion_tokens}")
print(f"Accepted tokens (prediction): "
      f"{usage.completion_tokens_details.accepted_prediction_tokens}")
print(f"Rejected tokens (prediction): "
      f"{usage.completion_tokens_details.rejected_prediction_tokens}")

# Jo højere forholdet mellem accepterede og samlede tokens er, desto større er gevinsten

Beslut automatisk

Da gevinsten udelukkende afhænger af anmodningstypen, bør beslutningen om at aktivere forudsigelse eller ej være kodificeret frem for at overlades til hver enkelt udvikler. Heuristikken nedenfor afviser forudsigelse på tekster, der er for korte, hvor overhead ved at sende dem udligner fordelen, og reserverer den til instrukser, der udtrykker en modificering.

def should_use_prediction(original_text: str, instruction: str) -> bool:
    """Heuristik til at afgøre, om Forudsagte output er det værd."""
    # Teksten skal være lang nok
    if len(original_text) < 200:
        return False

    # Instruktionen skal være en målrettet modificering
    edit_words = ["modify", "change", "replace", "add", "fix"]
    is_edit = any(word in instruction.lower() for word in edit_words)

    return is_edit

Den samme ræsonnement gælder for strukturerede data, hvor udbyttet er endnu bedre: En konfigurations-JSON beholder sine nøgler, indrykning og rækkefølge, og kun værdierne flytter sig.

import json

original_data = {
    "company": "Corsen AI",
    "employees": 42,
    "departments": ["Engineering", "Sales", "Marketing"],
    "address": {
        "street": "123 Avenue de la République",
        "city": "Paris",
        "zip_code": "75011",
    },
}

json_original = json.dumps(original_data, indent=2, ensure_ascii=False)

completion = client.chat.completions.create(
    model="gpt-4.1",
    messages=[
        {"role": "user", "content": (
            "Update the following JSON: change the number of employees "
            "to 58 and add the Data Science department. Respond with JSON only."
        )},
        {"role": "user", "content": json_original},
    ],
    prediction={
        "type": "content",
        "content": json_original,
    },
)

Tre forbehold før implementering. Streaming er kompatibelt, og det er endda her, latens-gevinsten er mest mærkbar. Flere parametre er dog ikke kompatible: n større end 1, logprobs, positiv presence_penalty eller frequency_penalty, lyd, andre modaliteter end tekst, max_completion_tokens og værktøjer (function calling). Endelig er funktionen bundet til modeller, der når slutningen af deres levetid: GPT-4o, GPT-4o mini, GPT-4.1 og GPT-4.1 mini stopper den 14. januar 2027, og ingen nyere model er annonceret som kompatibel. Til hurtig redigering på nuværende modeller er den bæredygtige vej at bede modellen om en diff eller en patch frem for hele filen.

Vigtige pointer

  • Forudsagte output gør svar hurtigere, når du kender den forventede struktur – kun i Chat Completions
  • Ideel til kode-redigering, JSON-opdateringer og delvis omskrivning
  • Tjek accepted_prediction_tokens for at måle den reelle gevinst
  • Afviste forudsigelses-tokens faktureres: Forudsig ikke tilfældigt
  • Brug dem ikke til helt nye genereringer
  • Kompatible modeller (GPT-4o, GPT-4.1 og deres mini-versioner) udfases den 14. januar 2027: Planlæg en alternativ løsning, såsom diff-generering