Spring til hovedindhold
Dansk— Vælg et sprog
Menu

End-to-end-optimering: fra prompt til netværk

Lektion 2 af 20 Opdateret 3. november 2026 Avanceret
På denne side
  1. Optimering er et system, ikke en parameter
  2. Optimer prompten
  3. Optimer API-parametre
  4. Optimer netværket
  5. Optimer efterbehandling
  6. Vigtige pointer

Lektion opdateret 3. november 2026 baseret på OpenAI-dokumentation: temperature og top_p accepteres kun med en ræsonneringsindsats på none, hvorimod GPT-5.6-modeller ræsonnerer som standard (medium). Kald, der sætter disse parametre, skal derfor specificere reasoning={"effort": "none"} (Responses API) eller reasoning_effort="none" (Chat Completions). Kilder: Brug af GPT-6 · GPT-5.6 Terra.

Optimering er et system, ikke en parameter

At reducere ventetid og omkostninger for en LLM-applikation handler ikke kun om at vælge en hurtigere model. Det er en kæde af optimeringer, der strækker sig fra prompten til netværkskonfigurationen, og det svageste led dikterer ydeevnen for resten. Et team, der halverer størrelsen på sit system-prompt, men lader sin server åbne en ny TLS-forbindelse for hver anmodning, vil miste i netværksoverhead, hvad det har sparet på tokens.

Rækkefølgen, hvori du griber disse håndtag an, betyder noget. Start med prompten, fordi den påvirker både omkostninger og ventetid uden at kræve infrastrukturændringer. Dernæst kommer API-parametre, så netværkskonfiguration og til sidst, hvordan din applikation forbruger svaret. Denne lektion guider dig gennem hvert håndtag i den rækkefølge.

Optimer prompten

Hvert input-token koster tid og penge, og de fleste produktions-prompts bærer på bagage fra deres prototypefase: instruktioner tilføjet én efter én, hvor hver omskriver den foregående. Din første refleks bør være at omskrive prompten tæt, fjerne tiltaleformer og gentagelser uden at røre ved de faktiske begrænsninger, der sendes til modellen.

# ❌ Omstændelig prompt
prompt_long = """
You are an expert financial analysis assistant. You must always
respond in a professional and structured manner. You must use
numerical data when possible. You must avoid unnecessary jargon.
You must be concise but complete.
Analyze the following quarterly report: ...
"""

# ✅ Optimeret prompt (samme resultat, færre tokens)
prompt_court = """Role: Senior financial analyst.
Constraints: Structured, numerical, concise.
Task: Analyze this quarterly report: ..."""

Begge versioner transmitterer nøjagtig de samme fem begrænsninger; den anden gør det uden de fem „You must”-sætninger, der ikke tilfører modellen noget. På en tjeneste, der behandler ti tusinde rapporter om dagen, betaler denne tredive sekunders omskrivning sig selv dagligt.

Vælg den rigtige model til opgaven

Det andet håndtag bygger på, at ikke hvert eneste kald kræver den samme model. At rute en feltudtræksopgave til en model med høj ræsonneringsevne betyder, at du betaler for kapacitet, opgaven ikke bruger, og venter længere på et identisk resultat.

OpgavetypeAnbefalet modelÅrsag
Klassificering / udtrækgpt-5.6-lunaHurtig, økonomisk
Kompleks ræsonneringgpt-5.6-terra med medium ræsonneringBedste kvalitet/omkostnings-forhold
Kritiske opgavergpt-5.6-sol med høj ræsonneringHøjeste kvalitet, langsommere
Højt volumengpt-5.6-luna via Batch API-50 % omkostninger

I praksis skal du kodificere dette valg i en ruteringsfunktion i stedet for at overlade det til udviklernes skøn; ellers vinder standardmodellen altid:

import openai

client = openai.OpenAI()

def route_model(task: str, complexity: str) -> str:
    """Vælger den optimale model baseret på opgaven."""
    if complexity == "low":
        return "gpt-5.6-luna"
    elif task in ("reasoning", "math", "code"):
        return "gpt-5.6-terra"
    elif complexity == "critical":
        return "gpt-5.6-sol"
    return "gpt-5.6-terra"

def optimized_call(prompt: str, task: str, complexity: str) -> str:
    model = route_model(task, complexity)
    response = client.responses.create(
        model=model,
        input=prompt,
    )
    return response.output_text

Optimer API-parametre

Et svar, der er for langt, spilder genereringstid, som ingen alligevel vil læse. Angiv altid max_output_tokens: dette er en hård grænse, der beskytter både din regning og din grænseflade ved at forhindre, at en dårligt formuleret prompt udvikler sig til en to-tusind-ords udflugt.

response = client.responses.create(
    model="gpt-5.6-terra",
    reasoning={"effort": "none"},  # temperature kræver effort none
    input="Summarize this text in one sentence.",
    max_output_tokens=100,  # Hård grænse
    temperature=0.0,         # Deterministisk = hurtigere
)

Sampling-parametre virker i samme retning. At sætte temperature=0 gør svar deterministiske og lidt hurtigere, hvilket er præcis, hvad du ønsker til udtræks- eller klassificeringsopgaver, hvor kreativitet er en kilde til varians, ikke en fordel. At reducere top_p til 0,1 begrænser søgerummet og fremskynder genereringen; reserver denne indstilling til opgaver, hvor kun én formulering er acceptabel, og behold standardværdier, hvor svarrigdom er en del af produktet.

Optimer netværket

Pakkerejser koster opsummeret på hvert kald, men de forbliver usynlige i dine applikationsmålinger. OpenAI-API’en hostes primært på USA’s østkyst: at placere din applikationsserver i samme region som endpointet kan give en potentiel gevinst på 50 til 150 millisekunder i netværksventetid. For en samtaleapplikation er dette en betydelig brøkdel af Time to First Token (TTFT).

Den anden gevinst kommer fra genbrug af forbindelser. Uden en pool gentager hver anmodning TLS-håndtrykket, hvilket tilføjer flere rundture, før nogen nyttige data strømmer. At konfigurere en HTTP-klient én gang for alle løser dette:

import httpx

# Klient med vedvarende forbindelsespulje
client_http = httpx.Client(
    base_url="https://api.openai.com/v1",
    timeout=60.0,
    limits=httpx.Limits(
        max_connections=20,
        max_keepalive_connections=10,
    ),
)

Optimer efterbehandling

Det sidste led er ofte det, folk glemmer: en applikation, der modtager et streamende svar, men venter til slutningen med at vise det, udligner alle fordelene ved streaming. Behandle svaret løbende i stedet for efter fuld modtagelse.

async def progressive_processing(prompt: str):
    """Behandler hver chunk, så snart den ankommer."""
    stream = client.responses.create(
        model="gpt-5.6-terra",
        input=prompt,
        stream=True,
    )

    buffer = ""
    for event in stream:
        if event.type == "response.output_text.delta":
            buffer += event.delta
            # Behandling pr. komplet sætning
            if buffer.endswith((".", "!", "?")):
                yield buffer.strip()
                buffer = ""

Opdeling ved komplette sætninger er et bevidst kompromis: at udsende hvert token producerer en rystende visning, mens venten på hele afsnittet genskaber følelsen af at vente. Sætningen er den enhed, læsere naturligt forbruger. Genbrug dette mønster, når din grænseflade skal vise, oplæse eller streame det, modellen producerer.

Vigtige pointer

  • Optimer prompten først: færre tokens = mindre ventetid og omkostninger
  • Rut til den rigtige model baseret på opgavens kompleksitet
  • Begræns max_output_tokens og brug temperature=0, når det er muligt
  • Genbrug HTTP-forbindelser og behandl svar via streaming