Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Transmisijos vamzdynas iš DDK į KT

Paskaita 12 iš 14 Atnaujinta 2026 m. lapkričio 3 d. Kūrėjas
Šiame puslapyje
  1. Prijunk DDK prie kalbos sintezės realiuoju laiku
  2. Vamzdyno architektūra
  3. Įgyvendinimas naudojant „Python“
  4. Buferizavimo strategija
  5. Garso atkūrimas realiuoju laiku
  6. Klaidų apdorojimas vamzdyne
  7. Svarbiausi punktai

Atnaujinta 2026 m. lapkričio 3 d., remiantis xAI Text to Speech puslapiu: kiekviename text.delta gali būti iki 60 000 simbolių. Šaltinis: Text to Speech.

Prijunk DDK prie kalbos sintezės realiuoju laiku

Galingiausias KT (kalbos į tekstą) WebSocket panaudojimas – sujungti jį su srautiniu DDK (didžiuoju kalbos modeliu). DDK generuoja tekstą žymenimis po vieną, kiekvienas žymuo per WebSocket siunčiamas į KT, o garsas grojamas jam atkeliaujant. Naudotojas girdi atsakymą dar DDK mąstant.

Vamzdyno architektūra

Duomenys teka trimis etapais:

Naudotojas -> DDK (srautas) -> KT WebSocket -> Garso atkūrimas
klausimas   teksto žymenys      audio.delta       garsiakalbis

Kiekvienas etapas veikia srautiniu režimu, todėl sumažinama suvokiama delsos trukmė. Naudotojas nelaukia, kol DDK sugeneruos visą atsakymą, kad pradėtų jį girdėti.

Įgyvendinimas naudojant „Python“

Štai pilnas vamzdynas, sujungiantis „Grok Chat Completions“ API su KT WebSocket:

import asyncio
import websockets
import json
import base64
import aiohttp

async def llm_to_speech(api_key, prompt, voice="rex", language="en"):
    # 1 žingsnis: KT WebSocket ryšys
    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 žingsnis: Srautinis DDK užklausimas
        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 žingsnis: Kiekvienas DDK žymuo -> KT 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
                        # Siųsti pilnus sakinius
                        if any(c in token for c in ".!?\n"):
                            await tts_ws.send(json.dumps({
                                "type": "text.delta",
                                "delta": buffer
                            }))
                            buffer = ""

                # Siųsti tai, kas liko buferyje
                if buffer:
                    await tts_ws.send(json.dumps({
                        "type": "text.delta",
                        "delta": buffer
                    }))

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

        # 4 žingsnis: Surinkti garso duomenis
        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)

Buferizavimo strategija

Siųsti kiekvieną žymenį į KT atskirai nėra idealu: sintezės variklis veikia geriau, kai turi kontekstą. Yra trys buferizavimo strategijos.

Pagal sakinį

Palauk sakinio skyrybos ženklo (., !, ?, eilutės lūžis) prieš siųsdamas:

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

Tai geriausias balansas tarp kokybės ir delsos.

Pagal dydį

Siųsk, kai buferis pasiekia tam tikrą dydį (pvz., 200 simbolių):

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

Tai paprasčiau, tačiau gali nutraukti žodį per pusę.

Pagal laiko limitą

Siųsk po uždelsto laiko be naujo žymens (naudinga, kai DDK mąsto):

last_token_time = time.time()

# Jei praėjo daugiau nei 500 ms be žymens, siųsk buferį
if time.time() - last_token_time > 0.5 and buffer:
    await tts_ws.send(...)
    buffer = ""

Garso atkūrimas realiuoju laiku

Norint atkurti garsą jam atkeliaujant (o ne tik jį surinkti), naudok asinchroninę eilę:

import asyncio

audio_queue = asyncio.Queue()

async def receive_audio(tts_ws):
    """Gauna garso fragmentus ir deda juos į eilę."""
    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)  # Pabaigos žymeklis
            break

async def play_audio():
    """Groja garso fragmentus iš eilės."""
    while True:
        chunk = await audio_queue.get()
        if chunk is None:
            break
        # Grok fragmentą (pyaudio, sounddevice ir kt.)
        play_chunk(chunk)

Paleidus receive_audio ir play_audio lygiagrečiai, atkūrimas prasideda gavus pirmąjį fragmentą.

Klaidų apdorojimas vamzdyne

Vamzdynas gali sugesti trijose vietose: DDK, KT arba tinkle. Apdorok kiekvieną atvejį:

async def robust_pipeline(api_key, prompt):
    try:
        audio = await llm_to_speech(api_key, prompt)
        return audio
    except aiohttp.ClientError:
        print("DDK klaida: patikrink ryšį")
    except websockets.ConnectionClosed:
        print("KT ryšys nutrūko: reikia prisijungti iš naujo")
    except json.JSONDecodeError:
        print("Neteisingas atsakymas: netikėtas formatas")
    except Exception as e:
        print(f"Netikėta klaida: {e}")
    return None

Svarbiausi punktai

  • Srautinis DDK, maitinantis KT WebSocket, užtikrina mažiausią delsą
  • Buferizuok pagal sakinius, kad pasiektum geriausią kokybės ir delsos balansą
  • Naudok asinchroninę eilę garso atkūrimui realiuoju laiku
  • Apdorok klaidas kiekviename vamzdyno etape
  • Bendras tekstas per WebSocket neribojamas (delta iki 60 000 simbolių)
  • 50 vienu metu vykdomų sesijų riba taikoma visai tavo komandai