Schritt-für-Schritt-Anleitung: Unterbrechungsmanagement mit OpenAI Realtime API

In diesem Artikel wird erläutert, wie Sie eine Gesprächsunterbrechungsfunktion mithilfe der OpenAI Realtime API implementieren.

Die Details der Implementierung sind im GitHub-Repository verfügbar.

Diese Implementierung basiert auf dem Code von Azure-Samples/aoai-realtime-audio-sdk. Eine ausführliche Erklärung des Codes finden Sie in diesem Artikel.

Audioeingang

In dieser Implementierung nutzen wir das Mikrofon und den Lautsprecher des lokalen PCs für die Audioein- und -ausgabe.

Das vom Mikrofon aufgenommene Audio wird zur Verarbeitung an den OpenAI Realtime API-Server gesendet.

Um Audio vom Mikrofon des lokalen PCs aufzunehmen, verwenden wir die Stream-Funktionalität der Pyaudio-Bibliothek. Der folgende Code richtet einen Stream für die Audioeingabe ein:

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()

Die Audioaufnahme erfolgt mithilfe von Threading.Thread für die Parallelverarbeitung. Die vom Mikrofon erhaltenen Audiodaten werden im Base64-Format codiert und in einer Warteschlange gespeichert.

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()

Die in der Warteschlange gespeicherten Base64-Zeichenfolgen werden als „input_audio_buffer.append“-Nachrichten an den OpenAI Realtime API-Server gesendet.

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)

Audioausgabe

Die Audiowiedergabe erfolgt über die Lautsprecher des lokalen PCs unter Verwendung der vom OpenAI Realtime API-Server empfangenen Audiodaten.

Die Audiodaten werden als „response.audio.delta“-Nachrichten vom Server empfangen. Da die empfangenen Daten in Base64 kodiert sind, werden sie dekodiert, in einer Warteschlange gespeichert und in ein abspielbares Format umgewandelt.

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)

Die in der Warteschlange gespeicherten Daten werden mittels Parallelverarbeitung über die Lautsprecher des lokalen PCs abgespielt. Dieser Wiedergabevorgang nutzt Threading.Thread, um sicherzustellen, dass die Audiodaten reibungslos in Echtzeit abgespielt werden.

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()

Umgang mit Gesprächsunterbrechungen

Die OpenAI Realtime API erkennt Konversationssegmente automatisch auf der Serverseite. Dies ermöglicht die Erkennung neuer Sprache und die Erstellung von Echtzeitantworten, selbst während die KI antwortet.

Bei der Audiowiedergabe auf einem lokalen PC ist es jedoch wichtig, die laufende Audiowiedergabe zu stoppen, um eine natürliche Unterbrechung des Gesprächs zu erreichen. Dieser Punkt erfordert Aufmerksamkeit. Die Erkennung der Benutzersprache wird vom OpenAI Realtime API-Server als „input_audio_buffer.speech_started“-Nachricht empfangen. Wenn diese Nachricht empfangen wird, wird die Wiedergabe gestoppt, indem die in der Warteschlange gespeicherten Audiodaten gelöscht werden.

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()

Für die Audioausgabe sind keine Änderungen erforderlich. Es funktioniert wie im zuvor erläuterten Code beschrieben.

Abschluss

Dieses Mal habe ich eine Python-Implementierung zur Gesprächsunterbrechung eingeführt.

Ich hoffe, dieser Artikel erweist sich als hilfreich für alle, die wie ich vor der Herausforderung stehen, KI-Sprache effektiv zu stoppen.

Darüber hinaus kann die Definition und Konfiguration von Stream-Instanzen die Qualität der Audiowiedergabe beeinflussen. Wenn bei der Audiowiedergabe Unterbrechungen auftreten, kann die Überprüfung dieser Einstellungen zur Verbesserung der Situation beitragen.

Vielen Dank, dass Sie bis zum Ende gelesen haben.

Das obige ist der detaillierte Inhalt vonSchritt-für-Schritt-Anleitung: Unterbrechungsmanagement mit OpenAI Realtime API. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!