Panduan Langkah demi Langkah: Pengurusan Gangguan dengan OpenAI Realtime API

Artikel ini memperkenalkan cara melaksanakan ciri gangguan perbualan menggunakan OpenAI Realtime API.

Butiran pelaksanaan tersedia dalam repositori GitHub.

Pelaksanaan ini berdasarkan kod daripada Azure-Samples/aoai-realtime-audio-sdk. Penjelasan terperinci tentang kod boleh didapati dalam artikel ini.

Input Audio

Dalam pelaksanaan ini, kami menggunakan mikrofon dan pembesar suara PC tempatan untuk input dan output audio.

Audio yang ditangkap daripada mikrofon dihantar ke pelayan OpenAI Realtime API untuk diproses.

Untuk menangkap audio daripada mikrofon PC tempatan, kami menggunakan fungsi strim pustaka pyaudio. Kod berikut menyediakan strim untuk input audio:

p = pyaudio.PyAudio()
input_default_input_index = p.get_default_input_device_info()['index']
input_stream = p.open(
    format=STREAM_FORMAT,
    channels=INPUT_CHANNELS,
    rate=INPUT_SAMPLE_RATE,
    input=True,
    output=False,
    frames_per_buffer=INPUT_CHUNK_SIZE,
    input_device_index=input_default_input_index,
    start=False,
)
input_stream.start_stream()

Tangkapan audio dilakukan menggunakan threading.Thread untuk pemprosesan selari. Data audio yang diperoleh daripada mikrofon dikodkan ke dalam format base64 dan disimpan dalam baris gilir.

def listen_audio(input_stream: pyaudio.Stream):
    while True:
        audio_data = input_stream.read(INPUT_CHUNK_SIZE, exception_on_overflow=False)
        if audio_data is None:
            continue
        base64_audio = base64.b64encode(audio_data).decode("utf-8")
        audio_input_queue.put(base64_audio)

threading.Thread(target=listen_audio, args=(input_stream,), daemon=True).start()

Rentetan base64 yang disimpan dalam baris gilir dihantar ke pelayan OpenAI Realtime API sebagai mesej "input_audio_buffer.append".

async def send_audio(client: RTLowLevelClient):
    while not client.closed:
        base64_audio = await asyncio.get_event_loop().run_in_executor(None, audio_input_queue.get)
        await client.send(InputAudioBufferAppendMessage(audio=base64_audio))
        await asyncio.sleep(0)

Output Audio

Main balik audio dilakukan melalui pembesar suara PC tempatan menggunakan data audio yang diterima daripada pelayan OpenAI Realtime API.

Data audio diterima sebagai mesej "response.audio.delta" daripada pelayan. Memandangkan data yang diterima dikodkan dalam base64, ia dinyahkod, disimpan dalam baris gilir dan ditukar kepada format yang boleh dimainkan.

async def receive_messages(client: RTLowLevelClient):
    while True:
        message = await client.recv()
        if message is None:
            continue
        match message.type:
            case "response.audio.delta":
                audio_data = base64.b64decode(message.delta)
                for i in range(0, len(audio_data), OUTPUT_CHUNK_SIZE):
                    audio_output_queue.put(audio_data[i:i+OUTPUT_CHUNK_SIZE])
                await asyncio.sleep(0)

Data yang disimpan dalam baris gilir dimainkan melalui pembesar suara PC tempatan menggunakan pemprosesan selari. Proses main balik ini menggunakan benang. Benang untuk memastikan data audio dimainkan dengan lancar dalam masa nyata.

def play_audio(output_stream: pyaudio.Stream):
    while True:
        audio_data = audio_output_queue.get()
        output_stream.write(audio_data)

p = pyaudio.PyAudio()
output_default_output_index = p.get_default_output_device_info()['index']
output_stream = p.open(
    format=STREAM_FORMAT,
    channels=OUTPUT_CHANNELS,
    rate=OUTPUT_SAMPLE_RATE,
    input=False,
    output=True,
    frames_per_buffer=OUTPUT_CHUNK_SIZE,
    output_device_index=output_default_output_index,
    start=False,
)
output_stream.start_stream()

threading.Thread(target=play_audio, args=(output_stream,), daemon=True).start()

Pengendalian Gangguan Perbualan

API Masa Nyata OpenAI secara automatik mengesan segmen perbualan di bahagian pelayan. Ini membolehkan pengesanan pertuturan baharu dan penciptaan respons masa nyata walaupun semasa AI bertindak balas.

Walau bagaimanapun, apabila memainkan audio pada PC tempatan, adalah penting untuk menghentikan main balik audio yang sedang berjalan untuk mencapai gangguan semula jadi perbualan. Perkara ini memerlukan perhatian. Pengesanan pertuturan pengguna diterima daripada pelayan OpenAI Realtime API sebagai mesej "input_audio_buffer.speech_started". Apabila mesej ini diterima, main balik dihentikan dengan mengosongkan data audio yang disimpan dalam baris gilir.

async def receive_messages(client: RTLowLevelClient):
    while True:
        message = await client.recv()
        # print(f"{message=}")
        if message is None:
            continue
        match message.type:
            case "input_audio_buffer.speech_started":
                print("Input Audio Buffer Speech Started Message")
                print(f"  Item Id: {message.item_id}")
                print(f"  Audio Start [ms]: {message.audio_start_ms}")
                while not audio_output_queue.empty():
                    audio_output_queue.get()

Bagi output audio, tiada pengubahsuaian diperlukan; ia beroperasi seperti yang diterangkan dalam kod yang dijelaskan sebelum ini.

Kesimpulan

Kali ini, saya memperkenalkan pelaksanaan Python untuk gangguan perbualan.

Saya harap artikel ini dapat membantu sesiapa sahaja yang menghadapi cabaran dengan menghentikan pertuturan AI dengan berkesan, seperti yang saya lakukan.

Selain itu, takrifan dan konfigurasi contoh strim boleh menjejaskan kualiti main balik audio. Jika anda mengalami gangguan dalam main balik audio, menyemak tetapan ini mungkin membantu memperbaiki keadaan.

Terima kasih kerana membaca sehingga habis.

Atas ialah kandungan terperinci Panduan Langkah demi Langkah: Pengurusan Gangguan dengan OpenAI Realtime API. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!