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

Pārraides konveijers no LLM uz TTS

Nodarbība 12 no 14 Atjaunota 2026. gada 3. novembris Programmētājs
Šajā lapā
  1. Savieno LLM ar runas sintēzi reāllaikā
  2. Konveijera arhitektūra
  3. Implementācija Python valodā
  4. Buferizācijas stratēģija
  5. Audio atskaņošana reāllaikā
  6. Kļūdu apstrāde konveijerā
  7. Galvenās atziņas

Atjaunināts 2026. gada 3. novembrī, pamatojoties uz xAI Text to Speech lapu: katrs text.delta var saturēt līdz 60 000 rakstzīmēm. Avots: Text to Speech.

Savieno LLM ar runas sintēzi reāllaikā

Visjaudīgākais TTS WebSocket pielietojums ir tā sasaiste ar straumējošu LLM. LLM ģenerē tekstu pa vienam tokenim, katrs tokens caur WebSocket nonāk TTS sistēmā, un audio atskaņošanās sākas līdz ar datu saņemšanu. Lietotājs dzird atbildi jau brīdī, kad LLM vēl domā.

Konveijera arhitektūra

Datu plūsma iziet cauri trim posmiem:

Lietotājs -> LLM (straumēšana) -> TTS WebSocket -> Audio (atskaņošana)
jautājums   teksta tokeni        audio.delta       skaļrunis

Katrs posms darbojas straumēšanas režīmā, kas minimizē uztveramo latentumu. Lietotājam nav jāgaida, kamēr LLM būs ģenerējis visu atbildi, lai sāktu to dzirdēt.

Implementācija Python valodā

Lūk, pilns konveijers, kas savieno Grok Chat Completions API ar TTS WebSocket:

import asyncio
import websockets
import json
import base64
import aiohttp

async def llm_to_speech(api_key, prompt, voice="rex", language="en"):
    # 1. solis: TTS WebSocket savienojums
    tts_uri = f"wss://api.x.ai/v1/tts?language={language}&voice={voice}"
    tts_headers = {"Authorization": f"Bearer {api_key}"}

    audio_chunks = []

    async with websockets.connect(tts_uri, additional_headers=tts_headers) as tts_ws:

        # 2. solis: LLM straumēšanas izsaukums
        async with aiohttp.ClientSession() as session:
            async with session.post(
                "https://api.x.ai/v1/chat/completions",
                headers={
                    "Authorization": f"Bearer {api_key}",
                    "Content-Type": "application/json"
                },
                json={
                    "model": "grok-4.5",
                    "messages": [{"role": "user", "content": prompt}],
                    "stream": True
                }
            ) as llm_response:

                # 3. solis: Katrs LLM tokens -> TTS delta
                buffer = ""
                async for line in llm_response.content:
                    line = line.decode().strip()
                    if not line.startswith("data: "):
                        continue
                    if line == "data: [DONE]":
                        break

                    chunk = json.loads(line[6:])
                    token = chunk["choices"][0].get("delta", {}).get("content", "")

                    if token:
                        buffer += token
                        # Sūti pabeigtus teikumus
                        if any(c in token for c in ".!?\n"):
                            await tts_ws.send(json.dumps({
                                "type": "text.delta",
                                "delta": buffer
                            }))
                            buffer = ""

                # Nosūti visu, kas palicis buferī
                if buffer:
                    await tts_ws.send(json.dumps({
                        "type": "text.delta",
                        "delta": buffer
                    }))

                await tts_ws.send(json.dumps({"type": "text.done"}))

        # 4. solis: Audio savākšana
        async for msg in tts_ws:
            data = json.loads(msg)
            if data["type"] == "audio.delta":
                audio_chunks.append(base64.b64decode(data["delta"]))
            elif data["type"] == "audio.done":
                break

    return b"".join(audio_chunks)

Buferizācijas stratēģija

Katra tokena nosūtīšana TTS sistēmai atsevišķi nav ideāls risinājums: sintēzes dzinējs sniedz labākus rezultātus, ja tam ir konteksts. Pastāv trīs buferizācijas stratēģijas.

Pa teikumiem

Gaidi teikuma beigšanas zīmi (., !, ?, jaunu rindu) pirms nosūtīšanas:

if any(c in token for c in ".!?\n"):
    await tts_ws.send(json.dumps({
        "type": "text.delta", "delta": buffer
    }))
    buffer = ""

Šis ir labākais līdzsvars starp kvalitāti un latentumu.

Pēc izmēra

Nosūti, kad bufers sasniedz noteiktu izmēru (piemēram, 200 rakstzīmes):

if len(buffer) >= 200:
    await tts_ws.send(json.dumps({
        "type": "text.delta", "delta": buffer
    }))
    buffer = ""

Tas ir vienkāršāk, taču var pārraut vārdu uz pusēm.

Pēc noilguma

Nosūti pēc kavēšanās, ja jauni tokeni netiek saņemti (noderīgi, kamēr LLM domā):

last_token_time = time.time()

# Ja pagājuši vairāk nekā 500 ms bez tokena, nosūti buferi
if time.time() - last_token_time > 0.5 and buffer:
    await tts_ws.send(...)
    buffer = ""

Audio atskaņošana reāllaikā

Lai atskaņotu audio uzreiz, tiklīdz tas tiek saņemts (nevis tikai savāktu to), izmanto asinhronu rindu:

import asyncio

audio_queue = asyncio.Queue()

async def receive_audio(tts_ws):
    """Saņem audio fragmentus un ievieto tos rindā."""
    async for msg in tts_ws:
        data = json.loads(msg)
        if data["type"] == "audio.delta":
            audio_bytes = base64.b64decode(data["delta"])
            await audio_queue.put(audio_bytes)
        elif data["type"] == "audio.done":
            await audio_queue.put(None)  # Beigu marķieris
            break

async def play_audio():
    """Atskaņo audio fragmentus no rindas."""
    while True:
        chunk = await audio_queue.get()
        if chunk is None:
            break
        # Atskaņo fragmentu (pyaudio, sounddevice u.c.)
        play_chunk(chunk)

Palaižot receive_audio un play_audio paralēli, atskaņošana sākas līdz ar pirmā fragmenta saņemšanu.

Kļūdu apstrāde konveijerā

Konveijers var izgāzties trīs vietās: LLM, TTS vai tīklā. Apstrādā katru no tām:

async def robust_pipeline(api_key, prompt):
    try:
        audio = await llm_to_speech(api_key, prompt)
        return audio
    except aiohttp.ClientError:
        print("LLM kļūda: pārbaudi savu savienojumu")
    except websockets.ConnectionClosed:
        print("TTS savienojums zaudēts: nepieciešama atkārtota savienošanās")
    except json.JSONDecodeError:
        print("Nederīga atbilde: negaidīts formāts")
    except Exception as e:
        print(f"Negaidīta kļūda: {e}")
    return None

Galvenās atziņas

  • Straumējošs LLM, kas baro TTS WebSocket, nodrošina viszemāko latentumu
  • Buferizē pa teikumiem, lai panāktu labāko līdzsvaru starp kvalitāti un latentumu
  • Izmanto asinhronu rindu audio atskaņošanai reāllaikā
  • Apstrādā kļūdas katrā konveijera posmā
  • Kopējais teksta apjoms caur WebSocket ir neierobežots (deltas līdz 60 000 rakstzīmēm)
  • 50 vienlaicīgu sesiju limits attiecas uz visu tavu komandu