Wie man die GPT-4o Audio-Vorschau mit LangChain und ChatOpenAI verwendet

Erweiterte Anwendungsfälle von gpt-4o-audio-preview

In diesem Abschnitt erfährst du, wie du Werkzeuge an das gpt-4o-audio-preview-Modell anbindest, komplexere Workflows abwickelst und sogar mehrere Schritte miteinander verketten kannst, um vollautomatische Lösungen zu erstellen. Wenn du schon immer einen Sprachassistenten bauen wolltest, der nicht nur Audiosignale transkribiert, sondern auch Informationen aus externen Quellen abruft, wird dieser Abschnitt hilfreich sein.

Werkzeug rufen

Beginnen wir mit dem Aufruf der Werkzeuge. Das bedeutet, dass du deinem KI-Modell beibringst, wie es externe Tools oder Funktionen nutzen kann, um seine Fähigkeiten zu verbessern. Anstatt nur Text oder Audio zu verarbeiten, kann das Modell zusätzliche Aufgaben übernehmen, wie z. B. Daten von APIs abrufen, Berechnungen durchführen oder sogar Wetterinformationen abrufen.

Das gpt-4o-audio-preview-Modell von OpenAI kann mit Hilfe der bind_tools -Methode von LangChain mit anderen Tools und Funktionen kombiniert werden. Mit dieser Methode kannst du einen reibungslosen Arbeitsablauf schaffen, bei dem das Modell selbst entscheidet, wann und wie es die von dir zur Verfügung gestellten Werkzeuge nutzt.

Ich führe dich durch ein praktisches Beispiel, wie du ein Werkzeug an das Modell bindest. In diesem Fall werden wir ein Tool binden, das das Wetter abruft.

Zuerst definieren wir ein pydantisches Modell, das das Werkzeug darstellt, das wir verwenden wollen. Dann binden wir dieses Werkzeug an das gpt-4o-audio-preview-Modell, damit es bei Bedarf aufgerufen werden kann. Hierfür benötigst du einen API-Schlüssel von OpenWeatherMap.

import requests
from pydantic import BaseModel, Field

# Define a tool schema using Pydantic
class GetWeather(BaseModel):
   """Get the current weather in a given location."""
   location: str = Field(..., description="The city and state, e.g. Edinburgh, UK")
   def fetch_weather(self):
       # Using OpenWeatherMap API to fetch real-time weather
       API_KEY = "YOUR_API_KEY_HERE"  # Replace with your actual API key
       base_url = f"http://api.openweathermap.org/data/2.5/weather?q={self.location}&APPID={API_KEY}&units=metric"      
       response = requests.get(base_url)      
       if response.status_code == 200:
           data = response.json()
           weather_description = data['weather'][0]['description']
           temperature = data['main']['temp']
           return f"The weather in {self.location} is {weather_description} with a temperature of {temperature}°C."
       else:
           # Print the status code and response for debugging
           print(f"Error: {response.status_code}, {response.text}")
           return f"Could not fetch the weather for {self.location}."

# Example usage
weather_tool = GetWeather(location="Edinburgh, GB")  # Using city name and country code
ai_msg = weather_tool.fetch_weather()
print(ai_msg)

Schauen wir mal, was es damit auf sich hat:

• Definiere das Werkzeug: Wir definieren ein Tool namens GetWeather, das einen Ort als Eingabe nimmt und das aktuelle Wetter für diesen Ort mithilfe der OpenWeatherMap API zurückgibt.
• Schönes Wetter in Edinburgh: Dieses Mal holen wir uns das Wetter für Edinburgh, Großbritannien.
• Wetterdaten in Echtzeit: Das Tool holt sich Echtzeit-Wetterdaten über eine externe API und gibt sie zurück.

In diesem Beispiel möchte ich wissen, wie das Wetter in Edinburgh ist. Als ich es ausführte, erhielt ich diese Ausgabe: Das Wetter in Edinburgh, GB ist wolkenverhangen mit einer Temperatur von 13,48°C.

Verkettung von Aufgaben: Aufbau von mehrstufigen Arbeitsabläufen

Durch die Verkettung von Aufgaben kannst du mehrstufige Workflows erstellen, die mehrere Tools und Modellaufrufe kombinieren, um komplexe Anfragen zu bearbeiten. Stell dir ein Szenario vor, in dem du möchtest, dass dein Assistent Audiodaten transkribiert und dann eine Aktion für den in den Audiodaten genannten Ort ausführt. In diesem Beispiel verknüpfen wir eine Audiotranskription mit einer Wetterabfrage, die auf dem transkribierten Ort basiert.

import base64
import requests
from pydantic import BaseModel, Field
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

# Define the tool schema for fetching weather
class GetWeather(BaseModel):
   """Get the current weather in a given location."""
   location: str = Field(..., description="The city and state, e.g. Edinburgh, UK")
   def fetch_weather(self):
       # Using OpenWeatherMap API to fetch real-time weather
       API_KEY = "YOUR_API_KEY_HERE"  # Replace with your actual API key
       base_url = f"http://api.openweathermap.org/data/2.5/weather?q={self.location}&appid={API_KEY}&units=metric"       
       response = requests.get(base_url)
       if response.status_code == 200:
           data = response.json()
           weather_description = data['weather'][0]['description']
           temperature = data['main']['temp']
           return f"The weather in {self.location} is {weather_description} with a temperature of {temperature}°C."
       else:
           return f"Could not fetch the weather for {self.location}."

# Instantiate the LLM model
llm = ChatOpenAI(
   model="gpt-4o-audio-preview"
)
# Function to handle audio transcription using the LLM
def audio_to_text(audio_b64: str) -> str:
   # Define the message to send for transcription
   messages = [
       (
           "human",
           [
               {"type": "text", "text": "Transcribe the following:"},
               {"type": "input_audio", "input_audio": {"data": audio_b64, "format": "wav"}},
           ],
       )
   ]
   # Invoke the model and get the transcription
   output_message = llm.invoke(messages)
   # Return the transcription from the model's output
   return output_message.content

# Create a prompt template for transcription and weather lookup
prompt = ChatPromptTemplate.from_messages(
   [
       ("system", "You are an assistant that transcribes audio and fetches weather information."),
       ("human", "Transcribe the following and tell me the weather in the location mentioned in the audio."),
   ]
)

# Bind the tool to the model
llm_with_tools = llm.bind_tools([GetWeather])

# Chain the transcription and weather tool
chain = prompt | llm_with_tools

# Read and encode the audio file in base64
audio_file = "weather_input.wav" #Replace with your audio file
with open(audio_file, "rb") as audio_file:
   audio_b64 = base64.b64encode(audio_file.read()).decode('utf-8')

# Transcribe the audio to get the location
transcribed_location = audio_to_text(audio_b64)

# Print the transcription result for debugging
print(f"Transcribed location: {transcribed_location}")

# Check if transcription returned a valid result
if transcribed_location:
   # Fetch weather for the transcribed location
   weather_tool = GetWeather(location=transcribed_location)
   weather_result = weather_tool.fetch_weather()
   print(f"Weather result: {weather_result}")
else:
   print("No valid location was transcribed from the audio.")

Lass uns den Code aufschlüsseln:

• Audio-Transkription: Der Nutzer gibt eine Audioeingabe (kodiert in base64). Diese Audiodaten werden an das Modell gesendet, das den Inhalt transkribiert. In der Transkription könnte zum Beispiel "Edinburgh" stehen.
• Wetter nachschlagen: Nach der Transkription der Audiodaten und der Bestimmung des Standorts ruft das Modell dann das Tool GetWeather auf, um das Wetter für diesen Ort zu ermitteln.
• Vollständig automatisierter Arbeitsablauf: Auf diese Weise entsteht ein automatisierter, mehrstufiger Arbeitsablauf, bei dem das Modell zunächst versteht, was in den Audiodaten gesagt wurde (Transkription) und dann auf diese Informationen reagiert, indem es relevante Wetterdaten abruft.

Für dieses Beispiel habe ich dem Modell eine Audiodatei gegeben, in der ich gesagt habe: "Edinburgh". Das ist die Ausgabe, die ich erhalten habe:Transcribed location: Edinburgh

Wetterergebnis: Das Wetter in Edinburgh ist wolkenverhangen mit einer Temperatur von 13,47°C.

Feinabstimmung gpt-4o-audio-preview

In manchen Fällen möchtest du das Modell feiner abstimmen, um bestimmte Aufgaben effektiver zu erledigen. Wenn du z.B. eine Anwendung entwickelst, die medizinische Audiodateien transkribiert, möchtest du vielleicht, dass das Modell die medizinischen Begriffe und den Fachjargon versteht. Mit OpenAI kannst du das Modell feinabstimmen, indem du es mit eigenen Datensätzen trainierst.

Schauen wir uns an, wie das geht:

import base64
from langchain_openai import ChatOpenAI

# Step 1: Instantiate the fine-tuned audio-capable model
fine_tuned_model = ChatOpenAI(
    temperature=0,
    model="ft:gpt-4o-audio-preview:your-organization::model-id"
)

# Step 2: Capture and encode the input audio file (medical report)
audio_file = "medical_report.wav"
with open(audio_file, "rb") as audio_file:
    audio_b64 = base64.b64encode(audio_file.read()).decode('utf-8')

# Step 3: Create the message structure for transcription request
messages = [
    (
        "human",
        [
            {"type": "text", "text": "Please transcribe this medical report audio."},
            {"type": "input_audio", "input_audio": {"data": audio_b64, "format": "wav"}},
        ],
    )
]

# Step 4: Invoke the fine-tuned model to transcribe the audio
result = fine_tuned_model.invoke(messages)

# Step 5: Extract and print the transcribed text from the response
transcription = result.content  # This contains the transcription
print(f"Transcription: {transcription}")

# Debugging: Print the full structure of the additional_kwargs for inspection
print(result.additional_kwargs)

Du kannst die Modelle aber auch für andere Anwendungsfälle anpassen, z. B. für juristische Transkriptionen, Kundendienstaufnahmen oder die Bearbeitung von Podcasts. 

Praktisches Beispiel: Einen sprachgesteuerten Assistenten bauen

Zum Schluss wollen wir uns ein praktisches Beispiel ansehen, in dem wir einen sprachgesteuerten Assistenten bauen, der auf Benutzeranfragen per Audio hört, eine Antwort erzeugt und per Audio antwortet. 

Aufschlüsselung des Arbeitsablaufs

Dies ist der Arbeitsablauf, dem wir folgen werden:

1. Der/die Nutzer/in spricht in ein Mikrofon, und der Ton wird aufgezeichnet.
2. Das Modell transkribiert den Ton.
3. Die Transkription wird verarbeitet, um eine Antwort zu generieren.
4. Das Modell erzeugt dann eine Audioantwort, die dem/der Nutzer/in vorgespielt werden kann.

Umsetzung

Schauen wir uns an, wie man das codiert:

import base64
from langchain_openai import ChatOpenAI

# Step 1: Instantiate the audio-capable model with configuration for generating audio
llm = ChatOpenAI(
   model="gpt-4o-audio-preview",
   temperature=0,
   model_kwargs={
       "modalities": ["text", "audio"],  # Enable both text and audio modalities
       "audio": {"voice": "alloy", "format": "wav"},  # Set the desired voice and output format
   }
)

# Step 2: Capture and encode the audio 
audio_file = "math_joke_audio.wav" #You can replace your audio file here
with open(audio_file, "rb") as audio_file:
   audio_b64 = base64.b64encode(audio_file.read()).decode('utf-8')

# Step 3: Create the message structure for transcription and audio response
messages = [
   (
       "human",
       [
           {"type": "text", "text": "Answer the question."},
           {"type": "input_audio", "input_audio": {"data": audio_b64, "format": "wav"}},
       ],
   )
]

# Step 4: Invoke the model to transcribe the audio and generate a response
result = llm.invoke(messages)

# Step 5: Extract the audio response
audio_response = result.additional_kwargs.get('audio', {}).get('data')  # Safely check if audio exists

# Step 6: Save the audio response to a file if it exists
if audio_response:
   # Decode the base64 audio data and save it as a .wav file
   audio_bytes = base64.b64decode(audio_response)
   with open("response.wav", "wb") as f:
       f.write(audio_bytes)
   print("Audio response saved as 'response.wav'")
else:
   print("No audio response available")

Wie es funktioniert

Schauen wir uns an, wie das funktioniert:

• Audio input: Der/die Nutzer/in gibt eine Audio-Eingabe, z. B. eine Frage (z. B. "Erzähl mir einen Mathe-Witz"). Das Audio wird in base64 kodiert und an den Assistenten weitergegeben.
• Transkription: Das Modell transkribiert die Audiodaten in Text. Diese Transkription ist verfügbar, wenn du sie protokollieren oder anzeigen möchtest.
• Antwortgenerierung: Auf der Grundlage der Transkription generiert das Modell mithilfe seines internen Wissens eine Antwort (z. B. "Die Hauptstadt von Frankreich ist Paris").
• Audioausgang: Die Antwort wird in ein Audioformat umgewandelt. Die Audiodaten werden als Datei gespeichert (z. B. "response.wav"), die dem Nutzer mit einem beliebigen Audioplayer vorgespielt werden kann.

Dieser Assistent ist für Gespräche mit Audio gemacht. Es hört auf die Stimme des Nutzers, versteht die Frage und antwortet dann mit seiner eigenen Stimme. Dieses Setup eignet sich hervorragend, um einfache Sprachassistenten zu erstellen, und du kannst es später bei Bedarf noch weiter ausbauen!

Fazit

In diesem Tutorial haben wir das gpt-4o-audio-preview-Modell von OpenAI erkundet und dabei die Einrichtung, die Audioeingabe und -ausgabe, fortgeschrittene Anwendungsfälle und sogar den Bau eines einfachen Sprachassistenten behandelt. Dieses leistungsstarke Modell bietet eine solide Grundlage für die Entwicklung realer audiofähiger Anwendungen.

Wenn du dein praktisches Wissen über LangChain verbessern willst, empfehle ich dir diese Blogs:

• Wie man mit Streamlit und LangChain Benutzeroberflächen für KI-Anwendungen erstellt
• RAG mit Llama 3.1 8B, Ollama und Langchain: Tutorial
• LangChain-Agenten bauen, um Aufgaben in Python zu automatisieren