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

Straumēta audio reāllaikā

Nodarbība 12 no 18 Atjaunota 2026. gada 3. novembris Programmētājs
Šajā lapā
  1. Straumēta audio reāllaikā
  2. Straumēšana ar TTS API
  3. Latentuma mērīšana
  4. Asinhronā straumēšana
  5. Iepriekšēja bufera aizpilde
  6. Integrācija ar LLM + TTS konveijeru
  7. Galvenās atziņas

Atjauninājums 2026. gada 2. novembrī — Audio modeļi. Vairāki šī kursa modeļi ir novecojuši: tts-1, tts-1-hd un gpt-4o-mini-tts pārtrauks darboties 2027. gada 6. janvārī (pēctecis: gpt-realtime-2.1-mini, ko OpenAI TTS rokasgrāmata norāda kā ** neatbalstītu ar /v1/audio/speech**: balss sintēzes migrācija pāriet uz Realtime API); gpt-realtime, gpt-4o-realtime un vecie audio modeļi — 2027. gada 20. janvārī (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe un /v1/audio/translations — 2027. gada 26. februārī (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Pilndupleksa balsij GPT-Live 1 ir pieejams API kopš 2026. gada 10. septembra. Atjaunināts 2026. gada 3. novembrī: LLM → TTS konveijers iepriekš apstrādāja jebkuru notikumu, kas saturēja lauku delta, tostarp funkciju izsaukumu argumentus vai spriešanas kopsavilkumus; tagad tas filtrē stingri tikai response.output_text.delta, proti, faktisko atbildes tekstu.

Straumēta audio reāllaikā

Balsa aģentā gaidīšana, līdz tiek ģenerēts viss audio fails pirms atskaņošanas sākšanas, rada nepieņemamu latentumu. TTS straumēšana ļauj sākt atskaņošanu, tiklīdz ierodas pirmie baiti, samazinot laiku līdz pirmajai atbildei līdz dažiem simtiem milisekunžu.

Straumēšana ar TTS API

TTS API atbalsta straumēšanu dabiski. Gaidot pilnu failu, tu saņem audio pa daļām:

from openai import OpenAI
import pyaudio

client = OpenAI()

def stream_tts_to_speaker(text: str, voice: str = "alloy"):
    """Ģenerē un atskaņo audio straumēšanas režīmā."""
    # Inicilizē audio atskaņotāju
    pa = pyaudio.PyAudio()
    player = pa.open(
        format=pyaudio.paInt16,
        channels=1,
        rate=24000,
        output=True
    )

    try:
        # Izveido straumēšanas atbildi
        with client.audio.speech.with_streaming_response.create(
            model="tts-1",
            voice=voice,
            input=text,
            response_format="pcm"  # Neapstrādāts PCM tiešai atskaņošanai
        ) as response:
            # Lasī un atskaņo pa daļām
            for chunk in response.iter_bytes(chunk_size=4096):
                player.write(chunk)

    finally:
        player.stop_stream()
        player.close()
        pa.terminate()

stream_tts_to_speaker("Sveiki, šī ir reāllaika straumēšanas atbilde.")

Formāts pcm ir ideāls straumēšanai, jo tam nav nepieciešama dekodēšana: neapstrādātie baiti ir gatavi tūlītējai atskaņošanai.

Latentuma mērīšana

Laiks līdz pirmajam baitam (TTFB) ir galvenais rādītājs straumēšanas veiktspējai:

import time

def measure_tts_latency(text: str, voice: str = "alloy") -> dict:
    """Mēra TTS straumēšanas latentumus."""
    start_time = time.time()
    first_byte_time = None
    total_bytes = 0

    with client.audio.speech.with_streaming_response.create(
        model="tts-1",
        voice=voice,
        input=text,
        response_format="pcm"
    ) as response:
        for chunk in response.iter_bytes(chunk_size=4096):
            if first_byte_time is None:
                first_byte_time = time.time()
            total_bytes += len(chunk)

    end_time = time.time()

    return {
        "ttfb_ms": round((first_byte_time - start_time) * 1000),
        "total_ms": round((end_time - start_time) * 1000),
        "total_bytes": total_bytes,
        "audio_duration_s": round(total_bytes / (24000 * 2), 2)
    }

metrics = measure_tts_latency("Sveiki, kā tev iet?")
print(f"TTFB: {metrics['ttfb_ms']}ms, Kopā: {metrics['total_ms']}ms")

Asinhronā straumēšana

Lietotņu servera pusē izmanto asinhrono klientu:

from openai import AsyncOpenAI
import asyncio

async_client = AsyncOpenAI()

async def stream_tts_async(text: str, voice: str = "alloy"):
    """Asinhrona TTS straumēšana serveriem."""
    chunks = []

    async with async_client.audio.speech.with_streaming_response.create(
        model="tts-1",
        voice=voice,
        input=text,
        response_format="pcm"
    ) as response:
        async for chunk in response.iter_bytes(chunk_size=4096):
            chunks.append(chunk)
            # Šeit tu nosūtītu daļu klientam, izmantojot WebSocket
            yield chunk

# Lietošana FastAPI serverī
from fastapi import FastAPI
from fastapi.responses import StreamingResponse

app = FastAPI()

@app.get("/tts/stream")
async def tts_stream(text: str, voice: str = "alloy"):
    return StreamingResponse(
        stream_tts_async(text, voice),
        media_type="audio/pcm"
    )

Iepriekšēja bufera aizpilde

Lai nodrošinātu vienmērīgu atskaņošanu bez pārtraukumiem, uzkrāj nelielu buferi pirms sākšanas:

async def buffered_tts_playback(
    text: str,
    voice: str = "alloy",
    buffer_size: int = 3  # Daļu skaits iepriekšējai ielādei
):
    """TTS atskaņošana ar iepriekš aizpildītu buferi."""
    pa = pyaudio.PyAudio()
    player = pa.open(
        format=pyaudio.paInt16,
        channels=1,
        rate=24000,
        output=True
    )

    buffer = []
    playback_started = False

    try:
        async with async_client.audio.speech.with_streaming_response.create(
            model="tts-1",
            voice=voice,
            input=text,
            response_format="pcm"
        ) as response:
            async for chunk in response.iter_bytes(chunk_size=4096):
                buffer.append(chunk)

                if not playback_started and len(buffer) >= buffer_size:
                    playback_started = True
                    # Iztukšo sākotnējo buferi
                    for buffered_chunk in buffer:
                        player.write(buffered_chunk)
                    buffer.clear()
                elif playback_started:
                    player.write(chunk)

        # Atskaņo atlikušās daļas
        for remaining in buffer:
            player.write(remaining)

    finally:
        player.stop_stream()
        player.close()
        pa.terminate()

Integrācija ar LLM + TTS konveijeru

Balsa aģentā, kas neizmanto Realtime API, tu vari apvienot LLM straumēšanu ar TTS straumēšanu:

async def llm_to_tts_pipeline(user_message: str):
    """Konveijers: Straumējošs LLM → Reāllaika straumējošs TTS."""
    # 1. posms: Uzkrāj LLM atbildi pa teikumiem
    sentence_buffer = ""

    stream = client.responses.create(
        model="gpt-5.6-luna",
        input=[{"role": "user", "content": user_message}],
        stream=True
    )

    for event in stream:
        # Runājami jābūt tikai atbildes tekstam
        if event.type == "response.output_text.delta":
            sentence_buffer += event.delta

            # Nosaka teikuma beigas
            if sentence_buffer.rstrip().endswith((".", "!", "?")):
                sentence = sentence_buffer.strip()
                sentence_buffer = ""

                # 2. posms: Straumē šo teikumu uz TTS
                stream_tts_to_speaker(sentence)

    # Apstrādā atlikušo buferi
    if sentence_buffer.strip():
        stream_tts_to_speaker(sentence_buffer.strip())

Galvenās atziņas

  • TTS straumēšana samazina TTFB līdz dažiem simtiem milisekunžu, sākot atskaņošanu pirms ģenerēšanas pabeigšanas
  • Formāts pcm ir optimāls straumēšanai: nav nepieciešama dekodēšana, tieša atskaņošana
  • Iepriekšējs buferis ar 2–3 daļām novērš pārtraukumus atskaņošanas sākumā
  • Asinhronais klients ir būtisks serveriem, kas apstrādā vairākus vienlaicīgus savienojumus
  • Straumējoša LLM un straumējoša TTS kombinēšana ļauj izveidot reaģējošu balsa aģentu bez Realtime API