Prestanda i produktion
På denna sida
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.
| Kod | Typ | Åtgärd |
|---|---|---|
| 429 Too Many Requests | Återställningsbart | Exponentiell backoff (lektion 3) |
| 500 Internal Server Error | Återställningsbart | Försök igen med backoff; felet ligger på serversidan |
| 502 / 503 Service Unavailable | Återställningsbart | Försök igen efter några sekunder |
| 400 Bad Request | Slutgiltigt | Felaktig begäran; åtgärda payloaden |
| 401 Unauthorized | Slutgiltigt | Ogiltig eller utgången API-nyckel |
| 413 Payload Too Large | Slutgiltigt | Prompten ö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.
| Metrik | Vad det avslöjar | Mål |
|---|---|---|
| TTFT | Upplevd initial latens | Övervaka per modell |
| Framgångsfrekvens | Integrationens tillförlitlighet | Större än 99,5 % |
| Cachefrekvens | Kvalitet på promptstruktur | Större än 50 % |
| Kostnad per begäran | Budgetavvikelse, rullande medelvärde | Stabil ö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