Äänen suoratoisto reaaliajassa
Tällä sivulla
Päivitys 2. marraskuuta 2026 — Äänimallit. Useat tämän kurssin malleista on poistumassa käytöstä:
tts-1,tts-1-hdjagpt-4o-mini-ttslakkaavat toimimasta 6. tammikuuta 2027 (seuraaja:gpt-realtime-2.1-mini, jonka OpenAI:n TTS-opas ilmoittaa ei tukevan päätepistettä/v1/audio/speech: puheentuotannon siirtyminen tapahtuu Realtime API:n kautta);gpt-realtime,gpt-4o-realtimeja vanhat äänimallit 20. tammikuuta 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeja/v1/audio/translations26. helmikuuta 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Täysdupleksista ääntä varten GPT-Live 1 on ollut saatavilla rajapinnassa 10. syyskuuta 2026 lähtien. Päivitetty 3. marraskuuta 2026: Aiemmin LLM → TTS -putki käsitteli kaikki tapahtumat, joissa olidelta-kenttä, mukaan lukien funktiokutsujen argumentit tai päättely-yhteenveto; nyt se suodattaa tarkasti vain kohdanresponse.output_text.delta, eli varsinaisen vastauksen tekstin.
Äänen suoratoisto reaaliajassa
Ääniagentissa koko äänitiedoston odottaminen valmiiksi ennen toiston aloittamista aiheuttaa hyväksymätöntä viivettä. TTS-suoratoisto mahdollistaa toiston aloittamisen heti ensimmäisten tavujen saavuttua, mikä lyhentää vasteen alkamisajan muutamaan sataan millisekuntiin.
Suoratoisto TTS-rajapinnan avulla
TTS-rajapinta tukee suoratoistoa natiivisti. Täydellisen tiedoston odottamisen sijaan vastaanotat äänen osissa:
from openai import OpenAI
import pyaudio
client = OpenAI()
def stream_tts_to_speaker(text: str, voice: str = "alloy"):
"""Tuota ja toista ääni suoratoistotilassa."""
# Alusta äänisoitin
pa = pyaudio.PyAudio()
player = pa.open(
format=pyaudio.paInt16,
channels=1,
rate=24000,
output=True
)
try:
# Luo suoratoistovaste
with client.audio.speech.with_streaming_response.create(
model="tts-1",
voice=voice,
input=text,
response_format="pcm" # Raaka PCM suoraa toistoa varten
) as response:
# Lue ja toista pala kerrallaan
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-muoto on ihanteellinen suoratoistolle, koska se ei vaadi purkamista: raakatavut ovat valmiita toistettavaksi välittömästi.
Viiveen mittaaminen
Ensimmäisen tavun aika (Time to First Byte, TTFB) on keskeinen mittari suoratoiston suorituskyvylle:
import time
def measure_tts_latency(text: str, voice: str = "alloy") -> dict:
"""Mittaa TTS-suoratoiston viiveet."""
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")
Asynkroninen suoratoisto
Palvelinpuolen sovelluksissa käytä asynkronista asiakasta:
from openai import AsyncOpenAI
import asyncio
async_client = AsyncOpenAI()
async def stream_tts_async(text: str, voice: str = "alloy"):
"""Asynkroninen TTS-suoratoisto palvelimille."""
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)
# Tästä lähetät palan asiakkaalle WebSocketin kautta
yield chunk
# Käyttö FastAPI-palvelimessa
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"
)
Esitäyttöpuskuri
Varmistaaksesi sujuvan toiston ilman katkoja, kerää pieni puskuri ennen aloitusta:
async def buffered_tts_playback(
text: str,
voice: str = "alloy",
buffer_size: int = 3 # Esiladattavien palojen määrä
):
"""TTS-toisto esitäyttöpuskurilla."""
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
# Tyhjennä alkuperäinen puskuri
for buffered_chunk in buffer:
player.write(buffered_chunk)
buffer.clear()
elif playback_started:
player.write(chunk)
# Toista loput palat
for remaining in buffer:
player.write(remaining)
finally:
player.stop_stream()
player.close()
pa.terminate()
Integrointi LLM + TTS -putkeen
Ei-reaaliaikaisessa ääniagentissa voit yhdistää LLM-suoratoiston TTS-suoratoistoon:
async def llm_to_tts_pipeline(user_message: str):
"""Putki: Suoratoistava LLM → Reaaliaikainen TTS-suoratoisto."""
# Vaihe 1: Kerää LLM-vastaus lauseittain
sentence_buffer = ""
stream = client.responses.create(
model="gpt-5.6-luna",
input=[{"role": "user", "content": user_message}],
stream=True
)
for event in stream:
# Vain vastauksen teksti pitäisi puhua
if event.type == "response.output_text.delta":
sentence_buffer += event.delta
# Havaitse lauseen loppu
if sentence_buffer.rstrip().endswith((".", "!", "?")):
sentence = sentence_buffer.strip()
sentence_buffer = ""
# Vaihe 2: Suoratoista tämä lause TTS:ään
stream_tts_to_speaker(sentence)
# Käsittele jäljellä oleva puskuri
if sentence_buffer.strip():
stream_tts_to_speaker(sentence_buffer.strip())
Keskeiset asiat
- TTS-suoratoisto lyhentää TTFB:n muutamaan sataan millisekuntiin aloittamalla toiston ennen generoinnin valmistumista
pcm-muoto on optimaalinen suoratoistolle: purkamista ei tarvita, suora toisto mahdollista- 2–3 palan esitäyttöpuskuri estää katkot toiston alussa
- Asynkroninen asiakas on välttämätön palvelimille, jotka käsittelevät useita samanaikaisia yhteyksiä
- Suoratoistavan LLM:n ja suoratoistavan TTS:n yhdistäminen mahdollistaa reagoivan ääniagentin ilman Realtime API:a