Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Prestanda i produktion

Lektion 11 av 14 Uppdaterad 29 juli 2026 Avancerad
På denna sida
  1. Utanför cachen: Övergripande prestanda
  2. Strömning: Att spara tid utan att egentligen spara tid
  3. Att välja modell för latens
  4. Hantering av fel utan att förvärra läget
  5. Tidsgränser och motståndskraft
  6. Vad du ska instrumentera
  7. Viktiga punkter

Utanför cachen: Övergripande prestanda

Cachning sänker kostnaderna, men en lyckad produktionsintegration handlar om mer än bara fakturan: användarens upplevda latens, hållbar genomströmning, tillförlitlighet mot tillfälliga fel och förmågan att diagnostisera försämringar. En applikation som kostar lite men svarar på 12 sekunder eller misslyckas var 50:e gång är inte prestandaoptimerad. Den här lektionen täcker de fyra dimensioner som spelar roll när du väl bemästrat kostnadsaspekten.

Strömning: Att spara tid utan att egentligen spara tid

För alla gränssnitt där en människa väntar på ett svar förändrar SSE-strömning (Server-Sent Events) upplevelsen radikalt. Utan det stirrar användaren på en markör medan modellen genererar 500 token; med det dyker de första orden upp efter några hundra millisekunder och läsningen påbörjas under själva genereringen. Den totala tiden är densamma, men den upplevda tiden minskar med en faktor på flera gånger.

import requests
import json

def appel_streaming(messages, model="grok-4.20"):
    reponse = requests.post(
        "https://api.x.ai/v1/chat/completions",
        headers={
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        },
        json={
            "model": model,
            "messages": messages,
            "stream": True
        },
        stream=True
    )

    for ligne in reponse.iter_lines():
        if ligne and ligne.startswith(b"data: "):
            donnees = ligne[6:]
            if donnees == b"[DONE]":
                break
            chunk = json.loads(donnees)
            token = chunk["choices"][0]["delta"].get("content", "")
            yield token

Parametern stream: True ändrar varken antalet debiterade token eller deras hastighet. Det du förbättrar är TTFT – time to first token (tid till första token). Notera att funktionen är en generator: den lämnar över kontrollen token för token, vilket låter dig skriva direkt till din servers HTTP-svar utan att behålla hela genereringen i minnet.

Att välja modell för latens

Den andra hävstången för latens är modellvalet, och det hänger främst på resoneringsinsatsen. En resonerande modell producerar osynliga resonemangstoken innan den utformar sitt svar: kvaliteten ökar, men fördröjningen ökar också. I ytterligheterna är grok-build-0.1 den snabbaste i katalogen, vilket gör den lämpad för användning i realtid som klassificering på flyget eller autokomplettering; grok-4.20-0309 i icke-resonerande variant och grok-4.3 erbjuder en rimlig kompromiss mellan kvalitet och hastighet; grok-4.5 med djup resonemangsförmåga finns i andra änden, reserverad för uppgifter som verkligen kräver det.

Den praktiska konsekvensen är att du inte väljer en modell för en hel applikation, utan för ett specifikt steg. Ett vanligt mönster är att låta ett snabbt första anrop avgöra – är denna begäran trivial, tvetydig eller komplex? – och sedan bara skicka den del av fallen som motiverar det till en resonerande modell. Du minskar både den genomsnittliga latensen och den genomsnittliga kostnaden utan att försämra hanteringen av svåra fall.

Hantering av fel utan att förvärra läget

Kod 429 som behandlades i lektion 3 är inte den enda du kommer att stöta på. Nyckelskillnaden ligger mellan fel som förtjänar ett nytt försök och de där ett nytt försök bara skapar onödig trafik.

KodTypÅtgärd
429 Too Many RequestsÅterställningsbartExponentiell backoff (lektion 3)
500 Internal Server ErrorÅterställningsbartFörsök igen med backoff; felet ligger på serversidan
502 / 503 Service UnavailableÅterställningsbartFörsök igen efter några sekunder
400 Bad RequestSlutgiltigtFelaktig begäran; åtgärda payloaden
401 UnauthorizedSlutgiltigtOgiltig eller utgången API-nyckel
413 Payload Too LargeSlutgiltigtPrompten överskrider kontextgränsen

Du kan koda denna regel på tre rader, och det är värt att isolera den i en funktion snarare än att sprida ut if-satser överallt:

def classifier_erreur(status_code):
    recuperable = {429, 500, 502, 503}
    return status_code in recuperable

Tidsgränser och motståndskraft

En dåligt inställd tidsgräns skapar två motsatta problem: är den för kort överger den begäranden som hade lyckats; är den för lång blockerar den dina arbetare medan köns längd ökar. Ställ in tre separata värden. Anslutningen måste etableras inom 10 sekunder; bortom det är problemet nätverket. Läsning i icke-strömmande läge skalas efter modellen: 120 sekunder för en resonerande modell, 60 sekunder för grok-build-0.1. Vid strömning är inte den totala varaktigheten den relevanta tröskeln utan intervallet mellan chunkar, satt till runt 30 sekunder.

En punkt förtjänar stor försiktighet: när en tidsgräns löper ut vid en lång generering, starta inte automatiskt om. Modellen kan redan ha konsumerat resonemangstoken som du kommer att betala för en andra gång, och ingenting garanterar att den första begäran inte lyckades på serversidan. En idempotensmekanism – en begäransnyckel du behåller för att känna igen dubbletter – eller en explicit återupptagning fungerar bättre än ett blindt nytt försök.

Vad du ska instrumentera

Fyra metrikfamiljer räcker för att diagnostisera de flesta incidenter.

MetrikVad det avslöjarMål
TTFTUpplevd initial latensÖvervaka per modell
FramgångsfrekvensIntegrationens tillförlitlighetStörre än 99,5 %
CachefrekvensKvalitet på promptstrukturStörre än 50 %
Kostnad per begäranBudgetavvikelse, rullande medelvärdeStabil över tid

Lägg till latens vid 95:e percentilen. Medelvärdet döljer alltid extremfall, och det är dessa som utlöser supportärenden: en P95 på 8 sekunder betyder att en användare av 20 väntar 8 sekunder, vilket inget medelvärde på 1,2 sekunder skulle avslöja.

Viktiga punkter

  • SSE-strömning minskar den upplevda latensen utan att påverka kostnaden
  • Välj en snabb modell för realtid och en resonerande modell för kvalitet
  • Skilj på återställningsbara fel (429, 500, 502/503) och slutgiltiga fel (400, 401)
  • Konfigurera tidsgränser anpassade efter den modell som används
  • Övervaka TTFT, framgångsfrekvens, cachefrekvens och genomsnittlig kostnad per begäran