Como usar a visualização de áudio GPT-4o com LangChain e ChatOpenAI

Casos de uso avançado do gpt-4o-audio-preview

Nesta seção, abordarei como vincular ferramentas ao modelo gpt-4o-audio-preview, lidar com fluxos de trabalho mais complexos e até mesmo encadear várias etapas para criar soluções totalmente automatizadas. Se você já quis criar um assistente de voz que não apenas transcreva áudio, mas também busque informações de fontes externas, esta seção será útil.

Chamada de ferramenta

Vamos começar com a chamada de ferramentas. Isso significa ensinar ao seu modelo de IA como usar ferramentas ou funções externas para aprimorar seus recursos. Em vez de apenas processar texto ou áudio, o modelo pode executar tarefas adicionais, como buscar dados de APIs, fazer cálculos ou até mesmo procurar informações meteorológicas.

O modelo gpt-4o-audio-preview da OpenAI pode ser combinado com outras ferramentas e funções usando o método bind_tools da LangChain. Com esse método, você pode criar um fluxo de trabalho tranquilo em que o modelo decide quando e como usar as ferramentas que você forneceu.

Vou orientar você em um exemplo prático de vinculação de uma ferramenta ao modelo. Nesse caso, vamos vincular uma ferramenta que busca o clima.

Primeiro, definimos um modelo Pydantic que representa a ferramenta que queremos usar. Em seguida, associamos essa ferramenta ao modelo gpt-4o-audio-preview para que ela possa ser chamada quando necessário. Para isso, você precisará de uma chave de API do 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)

Vamos ver o que está acontecendo:

• Definição da ferramenta: Definimos uma ferramenta chamada GetWeather, que recebe um local como entrada e retorna o clima atual para esse local usando a API OpenWeatherMap.
• Tempo agradável em Edimburgo: Desta vez, estamos buscando a previsão do tempo para Edimburgo, Reino Unido.
• Dados meteorológicos em tempo real: A ferramenta obtém dados meteorológicos em tempo real usando uma API externa e os retorna.

Neste exemplo específico, quero saber como está o tempo em Edimburgo. Quando o executei, obtive este resultado: O tempo em Edimburgo, GB, está nublado, com uma temperatura de 13,48°C.

Encadeamento de tarefas: Criação de fluxos de trabalho em várias etapas

Ao encadear tarefas, você pode criar fluxos de trabalho de várias etapas que combinam várias ferramentas e chamadas de modelo para lidar com solicitações complexas. Imagine um cenário em que você queira que seu assistente transcreva o áudio e, em seguida, execute uma ação para o local mencionado no áudio. Neste exemplo, encadearemos uma tarefa de transcrição de áudio com uma pesquisa de clima com base no local transcrito.

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

Vamos detalhar o código:

• Transcrição do áudio: O usuário fornece uma entrada de áudio (codificada em base64). Esse áudio é enviado para o modelo, que transcreve o conteúdo. Por exemplo, a transcrição pode dizer "Edinburgh".
• Pesquisa de clima: Depois de transcrever o áudio e determinar o local, o modelo chama a ferramenta GetWeather para obter o clima para esse local.
• Fluxo de trabalho totalmente automatizado: Essa configuração cria um fluxo de trabalho automatizado de várias etapas em que o modelo primeiro entende o que foi dito no áudio (transcrevendo-o) e, em seguida, age com base nessas informações, buscando dados meteorológicos relevantes.

Para este exemplo, forneci ao modelo um arquivo de áudio no qual eu dizia: "Edimburgo". Este é o resultado que obtive:Local transcrito: Edimburgo

Resultado do clima: O tempo em Edimburgo está nublado, com uma temperatura de 13,47°C.

Ajuste fino do gpt-4o-audio-preview

Em alguns casos, você pode querer ajustar o modelo para lidar com tarefas específicas de forma mais eficaz. Por exemplo, se você estiver criando um aplicativo que transcreve áudio médico, talvez queira que o modelo tenha um conhecimento profundo de termos e jargões médicos. O OpenAI permite que você faça o ajuste fino do modelo treinando-o em conjuntos de dados personalizados.

Vamos ver como você pode fazer isso:

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)

Isso usa um modelo ajustado especificamente treinado para lidar com áudio médico, mas você também pode ajustar modelos para outros casos de uso, como transcrições jurídicas, gravações de atendimento ao cliente ou edição de podcast. 

Exemplo prático: Criação de um assistente habilitado para voz

Por fim, vamos analisar um exemplo prático em que criamos um assistente habilitado para voz que ouve as consultas do usuário por meio de áudio, gera uma resposta e responde de volta usando áudio. 

Detalhamento do fluxo de trabalho

Este é o fluxo de trabalho que você seguirá:

1. O usuário fala em um microfone, e o áudio é capturado.
2. O modelo transcreve o áudio.
3. A transcrição é processada para gerar uma resposta.
4. Em seguida, o modelo gera uma resposta de áudio que pode ser reproduzida para o usuário.

Implementação

Vamos ver como você pode codificar isso:

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

Como funciona

Vamos detalhar como isso funciona:

• Entrada de áudio: O usuário fornece entrada de áudio, como fazer uma pergunta (por exemplo, "Tell me a math joke"). O áudio é codificado em base64 e passado para o assistente.
• Transcrição: O modelo transcreve o áudio em texto. Essa transcrição está disponível se você quiser registrá-la ou exibi-la.
• Geração de respostas: Com base na transcrição, o modelo gera uma resposta usando seu conhecimento interno (por exemplo, "A capital da França é Paris")
• Saída de áudio: A resposta é convertida em formato de áudio. O áudio é salvo como um arquivo (por exemplo, "response.wav"), que pode ser reproduzido para o usuário usando qualquer reprodutor de áudio.

Esse assistente foi criado para falar com áudio. Ele ouve a voz do usuário, entende a pergunta e, em seguida, responde usando sua própria voz. Essa configuração é ótima para criar assistentes de voz simples, e você pode torná-la mais avançada posteriormente, se necessário!

Conclusão

Neste tutorial, exploramos o modelo gpt-4o-audio-preview da OpenAI, abordando a configuração, a entrada/saída de áudio, os casos de uso avançados e até mesmo a criação de um assistente de voz básico. Esse modelo avançado oferece uma base sólida para a criação de aplicativos habilitados para áudio no mundo real.

Se você quiser aprimorar seu conhecimento prático sobre LangChain, recomendo estes blogs:

• Como criar interfaces de usuário para aplicativos de IA usando Streamlit e LangChain
• RAG With Llama 3.1 8B, Ollama e Langchain: Tutorial
• Criando agentes LangChain para automatizar tarefas em Python