Przejdź do głównej treści
Polski— Wybierz język
Menu

Wydajność w środowisku produkcyjnym

Lekcja 11 z 14 Zaktualizowano 29 lipca 2026 Zaawansowany
Na tej stronie
  1. Poza cache: ogólna wydajność
  2. Strumieniowanie: oszczędzanie czasu bez faktycznego skracania czasu
  3. Dobór modelu pod kątem opóźnienia
  4. Obsługa błędów bez pogarszania sytuacji
  5. Limit czasu i odporność
  6. Co instrumentować
  7. Kluczowe wnioski

Poza cache: ogólna wydajność

Cache obniża koszty, ale integracja produkcyjna zależy od czegoś więcej niż tylko od rachunku: od opóźnienia odczuwanego przez użytkownika, utrzymującej się przepustowości, odporności na błędy przejściowe oraz zdolności do diagnozowania degradacji. Aplikacja, która kosztuje mało, ale odpowiada po 12 sekundach lub zawodzi raz na 50 wywołań, nie jest wydajna. Ta lekcja omawia cztery wymiary, które mają znaczenie, gdy już opanowałeś kwestię kosztów.

Strumieniowanie: oszczędzanie czasu bez faktycznego skracania czasu

W przypadku każdego interfejsu, w którym człowiek czeka na odpowiedź, strumieniowanie SSE (Server-Sent Events) radykalnie zmienia postrzeganie czasu. Bez niego użytkownik wpatruje się w kursor, podczas gdy model generuje 500 tokenów; z nim pierwsze słowa pojawiają się po kilkuset milisekundach, a czytanie zaczyna się w trakcie generowania. Całkowity czas pozostaje ten sam, ale czas odczuwany skraca się kilkukrotnie.

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

Parametr stream: True nie zmienia ani liczby rozliczanych tokenów, ani ich stawki. To, co poprawiasz, to TTFT – time to first token (czas do pierwszego tokena). Zauważ, że funkcja jest generatorem: zwraca kontrolę token po tokenie, pozwalając Ci zapisywać dane bezpośrednio w odpowiedzi HTTP serwera bez przetrzymywania całej generacji w pamięci.

Dobór modelu pod kątem opóźnienia

Drugim dźwigniem wpływającym na opóźnienie jest wybór modelu, który zależy głównie od wysiłku wnioskowania. Model wnioskujący produkuje niewidoczne tokeny rozumowania przed sformułowaniem odpowiedzi: jakość rośnie, ale opóźnienie również. Skrajnie rzecz ujmując, grok-build-0.1 jest najszybszy w katalogu, co czyni go odpowiednim do zastosowań czasu rzeczywistego, takich jak klasyfikacja na bieżąco czy autouzupełnianie; grok-4.20-0309 w wariancie bez wnioskowania oraz grok-4.3 oferują rozsądny kompromis między jakością a szybkością; grok-4.5 z głębokim wnioskowaniem znajduje się na drugim biegunie i jest zarezerwowany dla zadań, które tego naprawdę wymagają.

Praktyczną konsekwencją jest to, że nie wybierasz modelu dla całej aplikacji, lecz dla konkretnego etapu. Powszechnym wzorcem jest wykonanie szybkiego, początkowego wywołania, które decyduje: czy to żądanie jest trywialne, niejednoznaczne, czy złożone? – a następnie kierowanie tylko tej części przypadków, która tego uzasadnia, do modelu wnioskującego. Dzieli to zarówno średnie opóźnienie, jak i średni koszt, nie degradując przy tym obsługi trudnych przypadków.

Obsługa błędów bez pogarszania sytuacji

Kod 429 omówiony w Lekcji 3 nie jest jedynym, z jakim się spotkasz. Kluczowe rozróżnienie dotyczy błędów, które warto ponowić, i takich, przy których ponawianie jedynie generuje niepotrzebny ruch.

KodCharakterDziałanie
429 Too Many RequestsOdwracalnyWykładnicze opóźnianie (Lekcja 3)
500 Internal Server ErrorOdwracalnyPonów z opóźnieniem; błąd po stronie serwera
502 / 503 Service UnavailableOdwracalnyPonów po kilku sekundach
400 Bad RequestOstatecznyBłędne żądanie; popraw ładunek
401 UnauthorizedOstatecznyNieprawidłowy lub wygasły klucz API
413 Payload Too LargeOstatecznyPrompt przekracza limit kontekstu

Możesz zakodować tę regułę w trzech liniach i warto wydzielić ją do funkcji, zamiast rozsiewać instrukcje if wszędzie:

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

Limit czasu i odporność

Źle ustawiony limit czasu (timeout) tworzy dwa przeciwstawne problemy: jeśli jest zbyt krótki, porzuca żądania, które odniosłyby sukces; jeśli zbyt długi, blokuje workerów, podczas gdy kolejka się wydłuża. Ustaw trzy limity osobno. Połączenie musi zostać nawiązane w ciągu 10 sekund; poza tym terminem problem leży po stronie sieci. Czas odczytu w trybie niestrumieniowym skaluje się z modelem: 120 sekund dla modelu wnioskującego, 60 sekund dla grok-build-0.1. W trybie strumieniowym istotnym progiem nie jest całkowity czas trwania, lecz odstęp między chunkami, ustawiany na około 30 sekund.

Jeden punkt wymaga szczególnej ostrożności: gdy limit czasu wygasa podczas długiej generacji, nie uruchamiaj automatycznie procesu od nowa. Model mógł już zużyć tokeny rozumowania, za które zapłacisz drugi raz, i nic nie gwarantuje, że pierwsze żądanie nie zakończyło się sukcesem po stronie serwera. Mechanizm idempotentności – klucz żądania, który pozwala rozpoznać duplikat – lub jawne wznowienie działania sprawdzają się lepiej niż ślepe ponawianie.

Co instrumentować

Cztery rodziny metryk wystarczają do zdiagnozowania większości incydentów.

MetrykaCo ujawniaCel
TTFTOdczuwane początkowe opóźnienieMonitoruj dla każdego modelu
Wskaźnik sukcesuNiezawodność integracjiWiększy niż 99,5%
Wskaźnik cacheJakość struktury promptówWiększy niż 50%
Koszt na żądanieDryf budżetu, średnia kroczącaStabilny w czasie

Dodaj opóźnienie na 95. percentylu (P95). Średnia zawsze maskuje przypadki skrajne, a to one wywołują zgłoszenia do wsparcia: P95 na poziomie 8 sekund oznacza, że jeden na 20 użytkowników czeka 8 sekund, czego żadna średnia 1,2 sekundy nie ujawni.

Kluczowe wnioski

  • Strumieniowanie SSE redukuje odczuwane opóźnienie bez wpływu na koszt
  • Wybierz szybki model do zastosowań czasu rzeczywistego, a model wnioskujący do zadań wymagających jakości
  • Rozróżniaj błędy odwracalne (429, 500, 502/503) od błędów ostatecznych (400, 401)
  • Konfiguruj limity czasu dostosowane do używanego modelu
  • Monitoruj TTFT, wskaźnik sukcesu, wskaźnik cache oraz średni koszt na żądanie