Bidirektsionaalne helivoogedus
Sellel lehel
Uuendatud 2. novembril 2026 – Helimudelid. Mitmed selles kursuses käsitletud mudelid on aegunud:
tts-1,tts-1-hdjagpt-4o-mini-ttslõpetavad töö 6. jaanuaril 2027 (asendajaks ongpt-realtime-2.1-mini, mida OpenAI TTS juhend kirjeldab kui mittetoetatud teenuse/v1/audio/speechpoolt: kõnesünteesi migratsioon viiakse üle Realtime API-le);gpt-realtime,gpt-4o-realtimeja vanad helimudelid 20. jaanuaril 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeja/v1/audio/translations26. veebruaril 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Täisdupleksseks hääleks on GPT-Live 1 olnud API-s saadaval alates 10. septembrist 2026.
Bidirektsionaalne helivoogedus
Bidirektsionaalne helivoogedus on Realtime API tuum. Sa saadad mikrofonist pidevalt helilõike ja mudel tagastab vastuseks pidevalt helilõike. Need kaks voogu on sõltumatud ja saavad töötada samaaegselt – just see teeb vestluse loomulikuks.
PCM16 helivorming
Realtime API kasutab 24 kHz mono 16-bitist PCM-vormingut. See on toore, tihendamata vorming: iga proov on 16-bitine märgiga täisarv. See valik eelistab madalat latentsust ribalaiuse efektiivsusele.
Helilõigud saadetakse JSON-sündmuste sees Base64-kodeerituna. Iga lõik esindab tavaliselt 20–100 ms heli.
Helide saatmine: mikrofoni hõivamine
Siin on näide, kuidas mikrofonist heli hõivata ja voogedada:
import asyncio
import sounddevice as sd
import numpy as np
import base64
import json
SAMPLE_RATE = 24000
CHUNK_DURATION_MS = 100
CHUNK_SIZE = int(SAMPLE_RATE * CHUNK_DURATION_MS / 1000)
async def stream_microphone(ws):
"""Hõiva mikrofon ja saada lõigud Realtime API-le."""
loop = asyncio.get_event_loop()
audio_queue = asyncio.Queue()
def audio_callback(indata, frames, time_info, status):
if status:
print(f"Audio warning: {status}")
# Teisenda int16-ks ja lisa järjekorda
pcm_data = (indata[:, 0] * 32767).astype(np.int16)
loop.call_soon_threadsafe(audio_queue.put_nowait, pcm_data)
# Käivita hõivamine
stream = sd.InputStream(
samplerate=SAMPLE_RATE,
channels=1,
dtype="float32",
blocksize=CHUNK_SIZE,
callback=audio_callback
)
with stream:
print("Mikrofon aktiivne – räägi nüüd...")
while True:
pcm_data = await audio_queue.get()
audio_b64 = base64.b64encode(pcm_data.tobytes()).decode("utf-8")
await ws.send(json.dumps({
"type": "input_audio_buffer.append",
"audio": audio_b64
}))
Serveripoolne helipuhver
Lõigud, mis saadetakse käsuga input_audio_buffer.append, kogunevad serveris puhvrisse. Seda puhvrit töödeldakse kahel viisil:
- Automaatne VAD-režiim (
server_vad): Server tuvastab, millal sa rääkimise lõpetad, ja fikseerib puhvri automaatselt. - Manuaalne režiim: Sa saadad sõnaselgelt käsuga
input_audio_buffer.commit, et töötlemine käivitada.
# Fikseeri helipuhver manuaalselt
await ws.send(json.dumps({
"type": "input_audio_buffer.commit"
}))
# Või tühjenda puhver ilma seda töötlemata
await ws.send(json.dumps({
"type": "input_audio_buffer.clear"
}))
Vastuse heli vastuvõtmine
Heli vastused saabuvad lõikudena sündmuste response.output_audio.delta kaudu. Sa pead need dekodeerima ja pidevalt esitama:
import pyaudio
async def play_response_audio(ws):
"""Võta vastu ja esita vastuse heli."""
pa = pyaudio.PyAudio()
player = pa.open(
format=pyaudio.paInt16,
channels=1,
rate=SAMPLE_RATE,
output=True,
frames_per_buffer=CHUNK_SIZE
)
try:
async for raw_message in ws:
event = json.loads(raw_message)
if event["type"] == "response.output_audio.delta":
# Dekodeeri Base64 helilõik
audio_bytes = base64.b64decode(event["delta"])
player.write(audio_bytes)
elif event["type"] == "response.output_audio.done":
print("Heli vastus lõppenud")
elif event["type"] == "response.output_audio_transcript.delta":
# Vastuse tekstiline transkriptsioon
print(event["delta"], end="", flush=True)
finally:
player.stop_stream()
player.close()
pa.terminate()
Täielik rakendus: häälevestlus
Siin on näide, kuidas ühendada hõivamine ja taasesitus täielikuks vestluseks:
async def conversation_vocale():
headers = {
"Authorization": f"Bearer {OPENAI_API_KEY}"
}
async with websockets.connect(URL, additional_headers=headers) as ws:
# Oota session.created
await ws.recv()
# Seadista seanss
await ws.send(json.dumps({
"type": "session.update",
"session": {
"type": "realtime",
"output_modalities": ["audio"],
"instructions": "You are a voice assistant. Respond in English.",
"audio": {
"input": {
"format": {"type": "audio/pcm", "rate": 24000},
"turn_detection": {
"type": "server_vad",
"threshold": 0.5,
"silence_duration_ms": 700
}
},
"output": {
"format": {"type": "audio/pcm", "rate": 24000},
"voice": "marin"
}
}
}
}))
await ws.recv() # session.updated
# Käivita hõivamine ja taasesitus paralleelselt
await asyncio.gather(
stream_microphone(ws),
play_response_audio(ws)
)
asyncio.run(conversation_vocale())
Samaaegsete voogude haldamine
Bidirektsionaalse voogeduse väljakutse seisneb selles, et saadad ja võtad vastu samaaegselt sama WebSocketi kaudu. asyncio.gather käivitab mõlemad korutiinid paralleelselt, kuid need jagavad sama WebSocketi objekti. Teek websockets käsitleb seda samaaegsust korrektselt.
Peamised punktid
- Heli edastatakse 24 kHz mono 16-bitise PCM-ina, Base64-kodeerituna JSON-sündmustes
- Lõigud on tavaliselt 20–100 ms heli, et saavutada hea kompromiss latentsuse ja üldkulude vahel
- Serveripoolne helipuhver kogub lõike kuni fikseerimiseni (VAD-režiimis automaatne)
- Vastuse taasesitus toimub lõik-haaval sündmuse
response.output_audio.deltakaudu asyncio.gathervõimaldab samaaegset hõivamist ja taasesitust samal WebSocketil