Comment utiliser la prévisualisation audio GPT-4o avec LangChain et ChatOpenAI

Cas d'utilisation avancés de gpt-4o-audio-preview

Dans cette section, je vous expliquerai comment lier des outils au modèle gpt-4o-audio-preview, gérer des flux de travail plus complexes et même enchaîner plusieurs étapes pour créer des solutions entièrement automatisées. Si vous avez toujours voulu créer un assistant vocal qui ne se contente pas de transcrire de l'audio, mais qui va aussi chercher des informations dans des sources externes, cette section vous sera utile.

Appel d'outils

Commençons par l'appel d'outils. Il s'agit d'enseigner à votre modèle d'IA comment utiliser des outils ou des fonctions externes pour améliorer ses capacités. Au lieu de se contenter de traiter du texte ou de l'audio, le modèle peut effectuer des tâches supplémentaires telles que l'extraction de données à partir d'API, des calculs ou même la recherche d'informations météorologiques.

Le modèle gpt-4o-audio-preview d'OpenAI peut être combiné avec d'autres outils et fonctions à l'aide de la méthode LangChain bind_tools. Grâce à cette méthode, vous pouvez créer un flux de travail fluide dans lequel le modèle décide quand et comment utiliser les outils que vous lui avez fournis.

Je vais vous présenter un exemple pratique de liaison d'un outil au modèle. Dans ce cas, nous allons lier un outil qui récupère la météo.

Tout d'abord, nous définissons un modèle pydantique qui représente l'outil que nous voulons utiliser. Ensuite, nous lions cet outil au modèle gpt-4o-audio-preview afin qu'il puisse être invoqué si nécessaire. Pour cela, vous aurez besoin d'une clé API de 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)

Voyons ce qu'il en est :

• Définir l'outil : Nous définissons un outil appelé GetWeather, qui prend un lieu en entrée et renvoie la météo actuelle pour ce lieu à l'aide de l'API OpenWeatherMap.
• Beau temps à Édimbourg : Cette fois-ci, nous allons chercher la météo pour Édimbourg, au Royaume-Uni.
• Données météorologiques en temps réel : L'outil récupère des données météorologiques en temps réel à l'aide d'une API externe et les renvoie.

Dans cet exemple particulier, je souhaite connaître le temps qu'il fait à Édimbourg. Lorsque je l'ai exécuté, j'ai obtenu le résultat suivant : Le temps à Edinburgh, GB est à nuages fragmentés avec une température de 13,48°C.

Enchaînement de tâches : Construire des flux de travail en plusieurs étapes

En enchaînant les tâches, vous pouvez créer des flux de travail en plusieurs étapes qui combinent plusieurs outils et appels de modèles pour traiter des demandes complexes. Imaginez un scénario dans lequel vous souhaitez que votre assistant transcrive un document audio et effectue ensuite une action pour le lieu mentionné dans le document audio. Dans cet exemple, nous allons enchaîner une tâche de transcription audio avec une recherche météorologique basée sur le lieu transcrit.

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.")

Décomposons le code :

• Transcription audio : L'utilisateur fournit une entrée audio (encodée en base64). Cet audio est envoyé au modèle, qui transcrit le contenu. Par exemple, la transcription peut indiquer "Edinburgh".
• Consultation de la météo : Après avoir transcrit l'audio et déterminé l'emplacement, le modèle appelle l'outil GetWeather pour obtenir le temps qu'il fait à cet endroit.
• Flux de travail entièrement automatisé : Cette configuration crée un flux de travail automatisé en plusieurs étapes dans lequel le modèle comprend d'abord ce qui a été dit dans l'audio (en le transcrivant) et agit ensuite sur cette information en recherchant les données météorologiques pertinentes.

Pour cet exemple, j'ai donné au modèle un fichier audio dans lequel je disais : "Edimbourg". Voici le résultat que j'ai obtenu :Transcribed location : Edinburgh

Résultats météorologiques : Le temps à Édimbourg est à nuages fragmentés avec une température de 13,47°C.

Mise au point gpt-4o-audio-preview

Dans certains cas, vous souhaiterez peut-être affiner le modèle pour traiter plus efficacement des tâches spécifiques. Par exemple, si vous créez une application qui transcrit des données audio médicales, vous voudrez peut-être que le modèle ait une connaissance approfondie des termes médicaux et du jargon. OpenAI vous permet d'affiner le modèle en l'entraînant sur des ensembles de données personnalisés.

Voyons comment procéder :

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)

Il s'agit d'un modèle affiné, spécialement formé pour traiter les données audio médicales, mais vous pouvez également affiner les modèles pour d'autres cas d'utilisation, tels que les transcriptions juridiques, les enregistrements du service clientèle ou l'édition de podcasts. 

Exemple pratique : Construire un assistant à commande vocale

Enfin, examinons un exemple pratique dans lequel nous construisons un assistant à commande vocale qui écoute les requêtes de l'utilisateur par le biais de l'audio, génère une réponse et répond par le biais de l'audio. 

Ventilation du flux de travail

Voici la procédure que nous allons suivre :

1. L'utilisateur parle dans un microphone et le son est enregistré.
2. Le modèle transcrit l'audio.
3. La transcription est traitée pour générer une réponse.
4. Le modèle génère ensuite une réponse audio qui peut être écoutée par l'utilisateur.

Mise en œuvre

Voyons comment coder cela :

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

Comment cela fonctionne-t-il ?

Voyons comment cela fonctionne :

• Entrée audio : L'utilisateur fournit une entrée audio, par exemple en posant une question (par exemple, "Racontez-moi une blague mathématique"). L'audio est encodé en base64 et transmis à l'assistant.
• Transcription : Le modèle transcrit l'audio en texte. Cette transcription est disponible si vous souhaitez l'enregistrer ou l'afficher.
• Génération de réponses : Sur la base de la transcription, le modèle génère une réponse à l'aide de ses connaissances internes (par exemple, "La capitale de la France est Paris").
• Sortie audio : La réponse est convertie en format audio. L'audio est enregistré dans un fichier (par exemple, "response.wav"), qui peut être lu par l'utilisateur à l'aide de n'importe quel lecteur audio.

Cet assistant est conçu pour parler avec l'audio. Il écoute la voix de l'utilisateur, comprend la question et y répond en utilisant sa propre voix. Cette configuration est idéale pour créer des assistants vocaux simples, et vous pouvez la rendre plus avancée par la suite si nécessaire !

Conclusion

Dans ce tutoriel, nous avons exploré le modèle gpt-4o-audio-preview d'OpenAI, couvrant la configuration, l'entrée/sortie audio, les cas d'utilisation avancés, et même la construction d'un assistant vocal de base. Ce modèle puissant constitue une base solide pour la création d'applications audio réelles.

Si vous souhaitez améliorer vos connaissances pratiques sur LangChain, je vous recommande ces blogs :

• Comment construire des interfaces utilisateur pour les applications d'IA en utilisant Streamlit et LangChain
• RAG avec Llama 3.1 8B, Ollama et Langchain : Tutoriel
• Construire des agents LangChain pour automatiser des tâches en Python