Straumēšana abos virzienos
Šajā lapā
Atjaunināts 2026. gada 2. novembrī — Audio modeļi. Vairāki šī kursa modeļi ir novecojuši:
tts-1,tts-1-hdungpt-4o-mini-ttspārtrauks darboties 2027. gada 6. janvārī (norādītā aizstājēja irgpt-realtime-2.1-mini, ko OpenAI TTS rokasgrāmata definē kā ** neatbalstītu ar/v1/audio/speech**: runas sintēzes migrācija pāriet uz Realtime API);gpt-realtime,gpt-4o-realtimeun vecie audio modeļi — 2027. gada 20. janvārī (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeun/v1/audio/translations— 2027. gada 26. februārī (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Pilndupleksa balss funkcionalitātei GPT-Live 1 ir pieejams API kopš 2026. gada 10. septembra.
Straumēšana abos virzienos
Straumēšana abos virzienos ir Realtime API pamatā. Tu nepārtraukti nosūti audio fragmentus no mikrofona, un modelis nepārtraukti atgriež atbildes audio fragmentus. Šīs divas plūsmas ir neatkarīgas un var darboties vienlaicīgi — tieši tas padara sarunu dabisku.
PCM16 audio formāts
Realtime API izmanto 24 kHz mono 16 bitu PCM formātu. Tas ir neapstrādāts, nesaspiests formāts: katrs paraugs ir 16 bitu zīmēts vesels skaitlis. Šī izvēle prioritāri nodrošina zemu latentumu, nevis joslas platuma efektivitāti.
Audio fragmenti tiek nosūtīti Base64 kodējumā JSON notikumu ietvaros. Katrs fragments parasti atbilst 20 līdz 100 ms ilgam audio ierakstam.
Audio nosūtīšana: Mikrofona uztveršana
Lūk, kā uztvert mikrofonu un straumēt audio:
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):
"""Uztver mikrofonu un nosūta fragmentus uz Realtime API."""
loop = asyncio.get_event_loop()
audio_queue = asyncio.Queue()
def audio_callback(indata, frames, time_info, status):
if status:
print(f"Audio brīdinājums: {status}")
# Konvertē uz int16 un ievieto rindā
pcm_data = (indata[:, 0] * 32767).astype(np.int16)
loop.call_soon_threadsafe(audio_queue.put_nowait, pcm_data)
# Sāk uztveršanu
stream = sd.InputStream(
samplerate=SAMPLE_RATE,
channels=1,
dtype="float32",
blocksize=CHUNK_SIZE,
callback=audio_callback
)
with stream:
print("Mikrofons aktīvs — runā tagad...")
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
}))
Audio buferis servera pusē
Fragmenti, kas nosūtīti, izmantojot input_audio_buffer.append, uzkrājas buferī servera pusē. Šo buferi apstrādā divos veidos:
- Automātiskais VAD režīms (
server_vad): Serveris nosaka, kad tu esi beidzis runāt, un automātiski fiksē buferi. - Manuālais režīms: Tu eksplicīti nosūti
input_audio_buffer.commit, lai iniciētu apstrādi.
# Manuāli fiksē audio buferi
await ws.send(json.dumps({
"type": "input_audio_buffer.commit"
}))
# Vai notīra buferi, to neapstrādājot
await ws.send(json.dumps({
"type": "input_audio_buffer.clear"
}))
Atbildes audio saņemšana
Atbildes audio ierodas fragmentos, izmantojot response.output_audio.delta notikumus. Tie ir jāatšifrē un jāatskaņo nepārtraukti:
import pyaudio
async def play_response_audio(ws):
"""Saņem un atskaņo atbildes audio."""
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":
# Atšifrē Base64 audio fragmentu
audio_bytes = base64.b64decode(event["delta"])
player.write(audio_bytes)
elif event["type"] == "response.output_audio.done":
print("Audio atbilde pabeigta")
elif event["type"] == "response.output_audio_transcript.delta":
# Atbildes teksta transkripcija
print(event["delta"], end="", flush=True)
finally:
player.stop_stream()
player.close()
pa.terminate()
Pilna lietotne: Balss saruna
Lūk, kā apvienot uztveršanu un atskaņošanu pilnvērtīgai sarunai:
async def conversation_vocale():
headers = {
"Authorization": f"Bearer {OPENAI_API_KEY}"
}
async with websockets.connect(URL, additional_headers=headers) as ws:
# Gaida session.created
await ws.recv()
# Konfigurē sesiju
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
# Palaiž uztveršanu un atskaņošanu paralēli
await asyncio.gather(
stream_microphone(ws),
play_response_audio(ws)
)
asyncio.run(conversation_vocale())
Vienlaicīgu plūsmu pārvaldība
Izaicinājums, strādājot ar straumēšanu abos virzienos, ir tas, ka tu vienlaicīgi sūti un saņem datus vienā un tajā pašā WebSocket savienojumā. asyncio.gather palaiž abas korutīnas paralēli, taču tās koplieto vienu un to pašu WebSocket objektu. Bibliotēka websockets šo vienlaicīgumu apstrādā korekti.
Galvenās atziņas
- Audio tiek pārraidīts kā 24 kHz mono 16 bitu PCM, kodēts Base64 formātā JSON notikumos
- Fragmenti parasti ir 20 līdz 100 ms ilgi, lai nodrošinātu labu līdzsvaru starp latentumu un pieskaitāmajām izmaksām
- Servera puses audio buferis uzkrāj fragmentus līdz fiksēšanai (automātiski VAD režīmā)
- Atbildes atskaņošana notiek pa fragmentiem, izmantojot
response.output_audio.delta asyncio.gatherļauj vienlaicīgi uztvert un atskaņot audio vienā WebSocket savienojumā