Garso srautinis perdavimas realiuoju laiku
Šiame puslapyje
Atnaujinta 2026 m. lapkričio 2 d. — Garso modeliai. Keli šio kurso modeliai yra pasenę:
tts-1,tts-1-hdirgpt-4o-mini-ttsnustos veikti 2027 m. sausio 6 d. (įpėdinis:gpt-realtime-2.1-mini, kurio, kaip nurodoma „OpenAI TTS“ gide, nepalaiko/v1/audio/speech: balso sintezės migracija perkeliama į „Realtime API“);gpt-realtime,gpt-4o-realtimeir senieji garso modeliai nustos veikti 2027 m. sausio 20 d. (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeir/v1/audio/translationsnustos veikti 2027 m. vasario 26 d. (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Visapusiškam dvipusiam balsui „GPT-Live 1“ API yra prieinamas nuo 2026 m. rugsėjo 10 d. Atnaujinta 2026 m. lapkričio 3 d.: Anksčiau LLM → TTS grandinė apdorodavo bet kokį įvykį, turintįdeltalauką, įskaitant funkcijų kvietimų argumentus arba samprotavimų santraukas; dabar ji griežtai filtruoja tikresponse.output_text.delta, tai yra tikrąjį atsakymo tekstą.
Garso srautinis perdavimas realiuoju laiku
Balso agente laukti, kol sugeneruojamas visas garso failas prieš pradedant jį groti, sukelia nepriimtiną delsą. TTS srautinis perdavimas leidžia pradėti groti vos gavus pirmuosius baitus, taip sutrumpinant laiką iki pirmojo atsakymo iki kelių šimtų milisekundžių.
Srautinis perdavimas naudojant TTS API
TTS API natūraliai palaiko srautinį perdavimą. Užuot laukęs viso failo, gauni garso duomenis gabalėliais:
from openai import OpenAI
import pyaudio
client = OpenAI()
def stream_tts_to_speaker(text: str, voice: str = "alloy"):
"""Generuoti ir groti garso srautiniu režimu."""
# Inicijuoti garso grotuvą
pa = pyaudio.PyAudio()
player = pa.open(
format=pyaudio.paInt16,
channels=1,
rate=24000,
output=True
)
try:
# Sukurti srautinį atsakymą
with client.audio.speech.with_streaming_response.create(
model="tts-1",
voice=voice,
input=text,
response_format="pcm" # Žalias PCM tiesioginiam grojimui
) as response:
# Skaityti ir groti gabalėlis po gabalėlio
for chunk in response.iter_bytes(chunk_size=4096):
player.write(chunk)
finally:
player.stop_stream()
player.close()
pa.terminate()
stream_tts_to_speaker("Hello, here is a real-time streaming response.")
pcm formatas idealiai tinka srautiniam perdavimui, nes jam nereikia dekoduoti: žali baitai yra paruošti nedelsiant groti.
Delsos matavimas
Laikas iki pirmojo baito (TTFB) yra pagrindinis srautinio perdavimo našumo rodiklis:
import time
def measure_tts_latency(text: str, voice: str = "alloy") -> dict:
"""Išmatuoti TTS srautinio perdavimo delsą."""
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("Hello, how are you?")
print(f"TTFB: {metrics['ttfb_ms']}ms, Total: {metrics['total_ms']}ms")
Asinchroninis srautinis perdavimas
Serverio pusės programoms naudok asinchroninį klientą:
from openai import AsyncOpenAI
import asyncio
async_client = AsyncOpenAI()
async def stream_tts_async(text: str, voice: str = "alloy"):
"""Asinchroninis TTS srautinis perdavimas serveriams."""
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)
# Čia siųstum gabalėlį klientui per „WebSocket“
yield chunk
# Naudojimas „FastAPI“ serveryje
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"
)
Išankstinis buferio užpildymas
Kad užtikrintum sklandų grojimą be trikdžių, prieš pradėdamas sukaupk nedidelį buferį:
async def buffered_tts_playback(
text: str,
voice: str = "alloy",
buffer_size: int = 3 # Iš anksto įkeliamų gabalėlių skaičius
):
"""TTS grojimas su išankstinio užpildymo buferiu."""
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
# Išsiųsti pradinį buferį
for buffered_chunk in buffer:
player.write(buffered_chunk)
buffer.clear()
elif playback_started:
player.write(chunk)
# Sugroti likusius gabalėlius
for remaining in buffer:
player.write(remaining)
finally:
player.stop_stream()
player.close()
pa.terminate()
Integravimas su LLM + TTS grandine
Nerealiojo laiko balso agente gali derinti LLM srautinį perdavimą su TTS srautiniu perdavimu:
async def llm_to_tts_pipeline(user_message: str):
"""Grandinė: Srautinis LLM → Realiojo laiko srautinis TTS."""
# 1 etapas: Kaupti LLM atsakymą pagal sakinius
sentence_buffer = ""
stream = client.responses.create(
model="gpt-5.6-luna",
input=[{"role": "user", "content": user_message}],
stream=True
)
for event in stream:
# Tarti reikia tik atsakymo tekstą
if event.type == "response.output_text.delta":
sentence_buffer += event.delta
# Aptikti sakinio pabaigą
if sentence_buffer.rstrip().endswith((".", "!", "?")):
sentence = sentence_buffer.strip()
sentence_buffer = ""
# 2 etapas: Siųsti šį sakinį į TTS srautu
stream_tts_to_speaker(sentence)
# Apdoroti likusį buferį
if sentence_buffer.strip():
stream_tts_to_speaker(sentence_buffer.strip())
Svarbiausi punktai
- TTS srautinis perdavimas sutrumpina TTFB iki kelių šimtų milisekundžių, pradėdamas groti prieš baigiant generavimą
pcmformatas yra optimalus srautiniam perdavimui: nereikia dekoduoti, galima groti tiesiogiai- 2–3 gabalėlių išankstinio užpildymo buferis apsaugo nuo trikdžių grojimo pradžioje
- Asinchroninis klientas yra būtinas serveriams, tvarkantiems kelis vienuolinius ryšius
- Srautinio LLM ir srautinio TTS derinimas leidžia sukurti reaguojaantį balso agentą nenaudojant „Realtime API“