Cómo utilizar la previsualización de audio GPT-4o con LangChain y ChatOpenAI

Casos de uso avanzados de gpt-4o-audio-preview

En esta sección, explicaré cómo vincular herramientas al modelo gpt-4o-audio-preview, manejar flujos de trabajo más complejos e incluso encadenar varios pasos para crear soluciones totalmente automatizadas. Si alguna vez has querido crear un asistente de voz que no sólo transcriba audio, sino que también obtenga información de fuentes externas, esta sección te será útil.

Llamada a la herramienta

Empecemos por la llamada a la herramienta. Se trata de enseñar a tu modelo de IA a utilizar herramientas o funciones externas para mejorar sus capacidades. En lugar de limitarse a procesar texto o audio, el modelo puede realizar tareas adicionales como obtener datos de API, hacer cálculos o incluso buscar información meteorológica.

El modelo gpt-4o-audio-preview de OpenAI puede combinarse con otras herramientas y funciones utilizando el método bind_tools de LangChain. Con este método, puedes crear un flujo de trabajo fluido en el que el modelo decida cuándo y cómo utilizar las herramientas que le has proporcionado.

Voy a guiarte a través de un ejemplo práctico de vinculación de una herramienta al modelo. En este caso, vamos a enlazar una herramienta que busque el tiempo.

En primer lugar, definimos un modelo pydántico que represente la herramienta que queremos utilizar. A continuación, vinculamos esa herramienta al modelo gpt-4o-audio-preview para que pueda ser invocada cuando sea necesario. Para ello, necesitarás una clave 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)

Veamos en qué consiste:

• Definir la herramienta: Definimos una herramienta llamada GetWeather, que toma una ubicación como entrada y devuelve el tiempo actual para esa ubicación utilizando la API OpenWeatherMap.
• Buen tiempo en Edimburgo: Esta vez, vamos a buscar el tiempo para Edimburgo, Reino Unido.
• Datos meteorológicos en tiempo real: La herramienta obtiene datos meteorológicos en tiempo real mediante una API externa y los devuelve.

En este ejemplo concreto, quiero saber el tiempo que hace en Edimburgo. Cuando lo ejecuté, obtuve este resultado: El tiempo en Edimburgo, GB, es de nubes rotas, con una temperatura de 13,48°C.

Encadenar tareas: Construir flujos de trabajo de varios pasos

Encadenando tareas, puedes crear flujos de trabajo de varios pasos que combinen varias herramientas y llamadas a modelos para gestionar solicitudes complejas. Imagina un escenario en el que quieres que tu asistente transcriba un audio y luego realice una acción para el lugar mencionado en el audio. En este ejemplo, encadenaremos una tarea de transcripción de audio con una búsqueda meteorológica basada en la ubicación transcrita.

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

Desglosemos el código:

• Transcripción de audio: El usuario proporciona una entrada de audio (codificada en base64). Este audio se envía al modelo, que transcribe el contenido. Por ejemplo, la transcripción podría decir "Edimburgo".
• Consulta meteorológica: Tras transcribir el audio y determinar la ubicación, el modelo llama a la herramienta GetWeather para obtener el tiempo de esa ubicación.
• Flujo de trabajo totalmente automatizado: Esta configuración crea un flujo de trabajo automatizado de varios pasos en el que el modelo primero entiende lo que se dijo en el audio (transcribiéndolo) y luego actúa en función de esa información obteniendo los datos meteorológicos pertinentes.

Para este ejemplo, le di al modelo un archivo de audio en el que decía: "Edimburgo". Este es el resultado que obtuve:Ubicación transcrita: Edimburgo

Resultado meteorológico: El tiempo en Edimburgo es de nubes rotas, con una temperatura de 13,47°C.

Ajuste fino gpt-4o-audio-preview

En algunos casos, puede que quieras afinar el modelo para manejar tareas específicas con mayor eficacia. Por ejemplo, si estás creando una aplicación que transcribe audio médico, puede que quieras que el modelo tenga un profundo conocimiento de los términos y la jerga médica. OpenAI te permite afinar el modelo entrenándolo con conjuntos de datos personalizados.

Veamos cómo hacerlo:

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)

Utiliza un modelo ajustado y entrenado específicamente para tratar audio médico, pero también puedes ajustar modelos para otros casos de uso, como transcripciones jurídicas, grabaciones de atención al cliente o edición de podcasts. 

Ejemplo práctico: Construir un asistente con voz

Por último, veamos un ejemplo práctico en el que construimos un asistente de voz que escucha las consultas del usuario mediante audio, genera una respuesta y responde mediante audio. 

Desglose del flujo de trabajo

Este es el flujo de trabajo que vamos a seguir:

1. El usuario habla a un micrófono y se captura el audio.
2. El modelo transcribe el audio.
3. La transcripción se procesa para generar una respuesta.
4. A continuación, el modelo genera una respuesta de audio que puede reproducirse ante el usuario.

Aplicación

Veamos cómo codificar esto:

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

Cómo funciona

Veamos cómo funciona:

• Entrada de audio: El usuario proporciona una entrada de audio, como hacer una pregunta (por ejemplo, "Cuéntame un chiste de matemáticas"). El audio se codifica en base64 y se pasa al asistente.
• Transcripción: El modelo transcribe el audio a texto. Esta transcripción está disponible si quieres registrarla o mostrarla.
• Generación de respuesta: A partir de la transcripción, el modelo genera una respuesta utilizando su conocimiento interno (por ejemplo, "La capital de Francia es París")
• Salida de audio: La respuesta se convierte en formato de audio. El audio se guarda como un archivo (por ejemplo, "respuesta.wav"), que el usuario puede reproducir utilizando cualquier reproductor de audio.

Este asistente está hecho para hablar con audio. Escucha la voz del usuario, entiende la pregunta y responde con su propia voz. Esta configuración es genial para crear asistentes de voz sencillos, ¡y puedes hacerla más avanzada más adelante si es necesario!

Conclusión

En este tutorial, exploramos el modelo gpt-4o-audio-preview de OpenAI, cubriendo la configuración, la entrada/salida de audio, los casos de uso avanzados e incluso la construcción de un asistente de voz básico. Este potente modelo proporciona una base sólida para crear aplicaciones de audio del mundo real.

Si quieres mejorar tus conocimientos prácticos sobre LangChain, te recomiendo estos blogs:

• Cómo construir interfaces de usuario para aplicaciones de IA utilizando Streamlit y LangChain
• RAG Con Llama 3.1 8B, Ollama y Langchain: Tutorial
• Construir agentes LangChain para automatizar tareas en Python