Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Straumēšanas optimizācija

Nodarbība 5 no 20 Atjaunota 2026. gada 28. jūlijs Augstākais
Šajā lapā
  1. Ko patiesībā maina straumēšana
  2. Straumes patēriņš klienta pusē
  3. Straumes pārsūtīšana uz pārlūkprogrammu
  4. Savienojuma uzturēšana laika gaitā
  5. Galvenās atziņas

Ko patiesībā maina straumēšana

Straumēšana nepaātrina modeļa darbību: tā padara gaidīšanu pieņemamu. Ja atbildes ģenerēšana ilgst piecas sekundes, lietotājs bez straumēšanas piecas sekundes skatās tukšā ekrānā, pirms saņem teksta bloku. Ar straumēšanu viņš pirmos vārdus redz pēc dažām simtdaļām sekundes un lasa līdzi, kamēr modelis raksta. Kopējais ilgums ir identisks, bet uztvere ir pilnīgi cita. Tieši tāpēc ražošanas vidē straumēšanas izlaišana gandrīz vienmēr ir dizaina kļūda, nevis apzināta izvēle.

Tomēr straumei jāplūst cauri visai tavai ķēdei. Ja API ģenerē straumi pareizi, bet tava lietotnes serveris to uzkrāj vai reversais starpniekserveris to buferē, lietotājs saņem visu vienā blokā: tu esi samaksājis par straumēšanas sarežģītību, negūstot tās priekšrocības. Tāpēc šī nodarbība izseko visu ceļu no API izsaukuma līdz pārlūkprogrammai.

Straumes patēriņš klienta pusē

Izmantojot Responses API, iestatot stream=True, atbilde pārvēršas tipētu notikumu secībā, caur kuru iterē, tiklīdz tie pienāk. Katrs teksta fragments nonāk response.output_text.delta notikumā; straumes beigas signalizē response.completed, kas nes pilnu atbildes objektu, noderīgu tokena lietojuma iegūšanai.

import openai

client = openai.OpenAI()

def generate_streaming(prompt: str):
    """Straumēta ģenerēšana, izmantojot Responses API."""
    stream = client.responses.create(
        model="gpt-5.6-terra",
        input=prompt,
        stream=True,
    )

    for event in stream:
        if event.type == "response.output_text.delta":
            print(event.delta, end="", flush=True)
        elif event.type == "response.completed":
            print()  # Jauna rinda beigās
            return event.response

Karogs flush=True nav kosmētisks: bez tā Python pats buferē izvadi, un tu nonāc pie tāda paša bloku uzvedības, no kuras centies izvairīties. Šī detaļa atkārtojas katrā ķēdes slānī, un tā ir galvenā straumēšanas grūtība.

Mehānisms attiecas arī uz funkciju izsaukumiem. Rīku argumenti tiek veidoti pakāpeniski, un tu vari tos attēlot ģenerēšanas laikā, lai signalizētu lietotājam, ka tiek formulēta meklēšana, nevis liktu viņam skatīties sasalušā saskarnē, kamēr modelis sagatavo savu izsaukumu.

tools = [
    {
        "type": "function",
        "name": "search_product",
        "description": "Meklē produktu katalogā.",
        "parameters": {
            "type": "object",
            "properties": {
                "query": {"type": "string"},
                "category": {"type": "string"},
            },
            "required": ["query"],
        },
    }
]

def streaming_with_tools(prompt: str):
    stream = client.responses.create(
        model="gpt-5.6-terra",
        input=prompt,
        tools=tools,
        stream=True,
    )

    for event in stream:
        match event.type:
            case "response.output_text.delta":
                print(event.delta, end="", flush=True)
            case "response.function_call_arguments.delta":
                # Pašlaik ģenerētie funkcijas argumenti
                print(f"[arg: {event.delta}]", end="")
            case "response.function_call_arguments.done":
                print(f"\n[Funkcijas izsaukums pabeigts]")

Straumes pārsūtīšana uz pārlūkprogrammu

Tavs frontends nerunā tieši ar OpenAI API – tas runā ar tavu serveri, kam tāpēc ir jāpārsūta straume. Servera nosūtītie notikumi (SSE) ir dabiskais formāts tam: HTTP atbilde, kas paliek atvērta, kur katra data: rinda nes JSON fragmentu. Tālāk redzamais piemērs pārsūta tekstu, tiklīdz tas pienāk, un pēc tam izsūtī gala ziņojumu ar tokena skaitu, ļaujot veikt rēķinu vai žurnālēšanu bez otrā izsaukuma.

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
import openai
import json

app = FastAPI()
client = openai.OpenAI()

@app.post("/api/chat")
async def chat_streaming(request: dict):
    prompt = request["message"]

    async def generate():
        stream = client.responses.create(
            model="gpt-5.6-terra",
            input=prompt,
            stream=True,
        )

        for event in stream:
            if event.type == "response.output_text.delta":
                data = json.dumps({"text": event.delta})
                yield f"data: {data}\n\n"
            elif event.type == "response.completed":
                usage = event.response.usage
                data = json.dumps({
                    "end": True,
                    "input_tokens": usage.input_tokens,
                    "output_tokens": usage.output_tokens,
                })
                yield f"data: {data}\n\n"

    return StreamingResponse(
        generate(),
        media_type="text/event-stream",
        headers={
            "Cache-Control": "no-cache",
            "X-Accel-Buffering": "no",  # Svarīgi nginx
        },
    )

Tad nāk reversais starpniekserveris, parastais aizdomās turamais, ja „straumēšana nedarbojas ražošanas vidē, lai gan lokāli tā strādāja”. Pēc noklusējuma nginx uzkrāj backend atbildi pirms tās pārsūtīšanas. Tālāk redzamā konfigurācija atspējo šo uzvedību tikai konkrētajam maršrutam.

location /api/chat {
    proxy_pass http://127.0.0.1:8000;
    proxy_buffering off;
    proxy_cache off;
    proxy_set_header Connection "";
    chunked_transfer_encoding on;
}

Savienojuma uzturēšana laika gaitā

Straume, kas atvērta vairākas desmit sekundes, ir vairāk pakļauta riskam nekā īss izsaukums: tīkla pārtraukums, kvotas sasniegšana, un ģenerēšana apstājas teikuma vidū. Tavai atkārtošanas stratēģijai ir jānošķir šie divi gadījumi, jo tiem nepieciešamas atšķirīgas pieejas. Savienojuma kļūda ir jāatkārto ar eksponenciālu atkāpšanos, dodot tīklam laiku atgūties, nevis bombardējot API; kvotas pārsniegšana ir jāatkārto pēc fiksētas gaidīšanas, jo ātruma ierobežojuma logs tiek atiestatīts regulāros intervālos.

import openai

def resilient_streaming(prompt: str, max_attempts: int = 3):
    """Straumēšana ar kļūdu apstrādi un atkārtošanu."""
    for attempt in range(max_attempts):
        try:
            stream = client.responses.create(
                model="gpt-5.6-terra",
                input=prompt,
                stream=True,
            )

            full_text = ""
            for event in stream:
                if event.type == "response.output_text.delta":
                    full_text += event.delta
                    yield event.delta

            return  # Veiksme, iziešana

        except openai.APIConnectionError:
            if attempt < max_attempts - 1:
                import time
                time.sleep(2 ** attempt)  # Eksponenciāla atkāpšanās
            else:
                raise
        except openai.RateLimitError:
            import time
            time.sleep(5)  # Fiksēta gaidīšana ātruma ierobežojumam

Viens pēdējais uzlabojums uzlabo lasīšanas komfortu. Katra tokena izsūtīšana rada trūkstošu tekstu, it īpaši, ja tava saskarne pielieto animāciju vai ja rezultāts tiek novirzīts uz teksta-runāšanu. Uzkrāšana līdz teikuma beigām dod ritmu, kas tuvāks cilvēka lasīšanai, par cenu nelielas papildu aizkaves pirmajā fragmentā.

def streaming_by_sentence(prompt: str):
    """Uzkrāj un izdod pa pilniem teikumiem."""
    buffer = ""

    stream = client.responses.create(
        model="gpt-5.6-terra",
        input=prompt,
        stream=True,
    )

    for event in stream:
        if event.type == "response.output_text.delta":
            buffer += event.delta
            # Meklē teikuma beigas
            for separator in [".\n", "!\n", "?\n", ". ", "! ", "? "]:
                if separator in buffer:
                    parts = buffer.split(separator, 1)
                    yield parts[0] + separator.rstrip()
                    buffer = parts[1] if len(parts) > 1 else ""

    if buffer.strip():
        yield buffer.strip()

Ņem vērā noslēdzošo if buffer.strip(): bez tā atbilde, kas nebeidzas ar spēcīgu interpunkciju, zaudētu savus pēdējos vārdus. Šāda kļūda testēšanas laikā paliek nepamanīta un ražošanas vidē izpaužas atbildēs, kas apgrieztas ar max_output_tokens.

Galvenās atziņas

  • Ražošanas vidē vienmēr izmanto straumēšanu, lai samazinātu uztverto latentumu
  • Konfigurē nginx ar proxy_buffering off priekš SSE
  • Apstrādā kļūdas ar atkārtošanu un eksponenciālu atkāpšanos
  • Uzkrāj pa teikumiem dabiskākai attēlošanai