Премини към основното съдържание
Български— Изберете език
Меню

Производителност в продукционна среда

Урок 11 от 14 Обновен 29 юли 2026 г. Напреднало
На тази страница
  1. Отвъд кеширането: цялостна производителност
  2. Стрийминг: спестяване на време без реално спестяване на време
  3. Избор на модел за латентност
  4. Обработка на грешки без влошаване на ситуацията
  5. Таймаути и устойчивост
  6. Какво да мониторите
  7. Ключови изводи

Отвъд кеширането: цялостна производителност

Кеширането намалява разходите, но успешната интеграция в продукционна среда зависи от много повече от крайната сметка: възприемана латентност от потребителя, устойчив пропускателен капацитет, надеждност при преходни грешки и способност за диагностициране на влошаване на работата. Приложение, което струва малко, но отговаря след 12 секунди или се проваля веднъж на всеки 50 пъти, не е производително. Този урок разглежда четирите измерения, които имат значение, след като сте усвоили контрола на разходите.

Стрийминг: спестяване на време без реално спестяване на време

За всеки интерфейс, където човек чака отговор, стриймингът чрез SSE (Server-Sent Events) променя радикално възприятието. Без него потребителят гледа мигащия курсор, докато моделът генерира 500 токена; с него първите думи се появяват след няколкостотин милисекунди и четенето започва още по време на генерирането. Общото време е същото, но възприеманото време се съкращава няколкократно.

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

Параметърът stream: True не променя нито броя на таксуваните токени, нито тяхната скорост. Подобрявате TTFT – времето до първия токен. Обърнете внимание, че функцията е генератор: тя връща контрола токен по токен, позволявайки ви да записвате директно в HTTP отговора на вашия сървър, без да държите цялата генерация в паметта.

Избор на модел за латентност

Вторият лост за латентност е изборът на модел и той зависи основно от усилието за разсъждение. Модел за разсъждение произвежда невидими токени за разсъждение, преди да изготви отговора си: качеството се повишава, но забавянето също нараства. В крайните случаи grok-build-0.1 е най-бързият в каталога, което го прави подходящ за употреба в реално време като класификация в движение или автоматично довършване; grok-4.20-0309 във вариант без разсъждение и grok-4.3 предлагат разумен компромис между качество и скорост; grok-4.5 с дълбоко разсъждение е на другия полюс и е запазен за задачи, които наистина го изискват.

Практическото следствие е, че не избирате модел за цялото приложение, а за конкретна стъпка. Често срещан модел е бързо първоначално извикване да реши дали заявката е тривиална, двусмислена или сложна, след което само частта от случаите, които го оправдават, се изпращат към модел за разсъждение. Така намалявате както средната латентност, така и средната цена, без да влошавате обработката на трудните случаи.

Обработка на грешки без влошаване на ситуацията

Кодът 429, разгледан в Урок 3, не е единственият, с който ще се сблъскате. Ключовата разлика е между грешки, които заслужават повторен опит, и такива, при които повторението просто добавя ненужен трафик.

КодХарактерДействие
429 Too Many RequestsВъзстановимаЕкспоненциално отлагане (Урок 3)
500 Internal Server ErrorВъзстановимаПовторен опит с отлагане; грешката е от страна на сървъра
502 / 503 Service UnavailableВъзстановимаПовторен опит след няколко секунди
400 Bad RequestОкончателнаНеправилен формат на заявката; поправете полезния товар
401 UnauthorizedОкончателнаНевалиден или изтекъл API ключ
413 Payload Too LargeОкончателнаПромптът надвишава лимита на контекста

Можете да кодирате това правило в три реда и си струва да го изолирате във функция, вместо да разпръсквате оператори if навсякъде:

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

Таймаути и устойчивост

Лошо зададеният таймаут създава два противоположни проблема: ако е твърде кратък, той изоставя заявки, които биха успели; ако е твърде дълъг, блокира работните ви процеси, докато опашката нараства. Задайте три отделни стойности. Връзката трябва да се установи за 10 секунди; след това проблемът е в мрежата. Четането в режим без стрийминг зависи от модела: 120 секунди за модел за разсъждение, 60 секунди за grok-build-0.1. При стрийминг съответният праг не е общата продължителност, а интервалът между чънковете, зададен на около 30 секунди.

Един момент изисква особено внимание: когато таймаут изтече при дълга генерация, не рестартирайте автоматично. Моделът може вече да е консумирал токени за разсъждение, за които ще платите втори път, и нищо не гарантира, че първата заявка не е успяла от страна на сървъра. Механизъм за идемпотентност – ключ на заявката, който запазвате, за да разпознаете дубликат – или изрично възобновяване работи по-добре от сляпо повторение.

Какво да мониторите

Четири семейства метрики са достатъчни за диагностициране на повечето инциденти.

МетрикаКакво разкриваЦел
TTFTВъзприемана начална латентностМониторинг за всеки модел
Коефициент на успехНадеждност на интеграциятаПо-голям от 99,5%
Коефициент на кеширанеКачество на структурата на промптоветеПо-голям от 50%
Разход за заявкаОтклонение на бюджета, плъзгаща се средна стойностСтабилен във времето

Добавете латентност при 95-ия перцентил. Средната стойност винаги маскира екстремните случаи, а те са тези, които предизвикват тикети за поддръжка: P95 от 8 секунди означава, че един на всеки 20 потребители чака 8 секунди, което никаква средна стойност от 1,2 секунди не би разкрила.

Ключови изводи

  • Стриймингът чрез SSE намалява възприеманата латентност, без да влияе на разходите
  • Изберете бърз модел за работа в реално време и модел за разсъждение за качество
  • Разграничавайте възстановимите грешки (429, 500, 502/503) от окончателните грешки (400, 401)
  • Конфигурирайте таймаути, подходящи за използвания модел
  • Мониторинг на TTFT, коефициента на успех, коефициента на кеширане и средния разход за заявка