GPT-4o Audio Preview gebruiken met LangChain en ChatOpenAI

Virtuele omgeving en afhankelijkheden

Voordat we OpenAI's gpt-4o-audio-preview-model gebruiken, richten we een virtuele omgeving in voor je project. Dit houdt alles georganiseerd en voorkomt afhankelijkheidsconflicten, wat vooral handig is als je aan meerdere projecten werkt.

Wat is een virtuele omgeving?

Stel dat je twee verschillende projecten hebt. Het ene vereist versie 1.0 van een pakket, terwijl het andere versie 2.0 nodig heeft. Als je alles globaal installeert, krijg je conflicten.

Virtuele omgevingen creëren een geïsoleerde werkruimte, een soort bubbel, waarin je alles kunt installeren wat je voor een specifiek project nodig hebt. Als je een omgeving voor je project aanmaakt, hoef je je geen zorgen meer te maken over het stukmaken van de Python-installatie van je systeem of conflicterende pakketten.

De virtuele omgeving aanmaken en activeren

Laten we beginnen met het aanmaken van een virtuele omgeving voor ons project. We gebruiken Python’s ingebouwde venv-module. We moeten:

1. Navigeer naar je projectmap—daar wil je je omgeving laten leven. Als je nog geen projectmap hebt, maak er dan een aan.
2. Zodra je in de map zit, is het tijd om de virtuele omgeving te maken. Op macOS of Linux voer je python3 -m venv env uit. Op Windows ziet het er zo uit: python -m venv env.
1. Let op: venv is Python’s tool om virtuele omgevingen te maken, en env is de naam van de omgevingsmap. Je kunt deze noemen zoals je wilt: env, venv, my_project_env, enz. Het is goed gebruik om het kort en simpel te houden
3. Nu je je virtuele omgeving hebt gemaakt, is het tijd om deze te activeren. Deze stap is cruciaal, want zo zorg je dat alle pakketten die je installeert alleen dit specifieke project beïnvloeden.
1. Op macOS of Linux activeer je met source env/bin/activate. Op Windows gebruik je: .\env\Scripts\activate

Je merkt dat je terminalprompt verandert naar iets als env—dat is het teken dat je in je virtuele omgeving werkt. Vanaf nu zijn alle pakketten die je installeert of commando’s die je uitvoert geïsoleerd tot dit project.

langchain-openai installeren

Met je omgeving geactiveerd is het tijd om de tools te installeren die je nodig hebt. Omdat we met OpenAI en LangChain werken, beginnen we met het installeren van het pakket langchain-openai. Dit pakket laat ons met de modellen van OpenAI communiceren.

Voer dit uit in je terminal: pip install langchain-openai.

Omgevingsvariabelen instellen

De volgende stap is ervoor zorgen dat gevoelige informatie, zoals API-sleutels, niet hardcoded in je scripts terechtkomt. Dat doen we door omgevingsvariabelen in te stellen.

Allereerst heb je toegang nodig tot de modellen van OpenAI. Als je dat nog niet hebt, ga dan naar het OpenAI-platform en maak een account aan. Nadat je je hebt aangemeld, moet je een API-sleutel genereren. Deze API-sleutel is jouw toegangspas tot de modellen van OpenAI, waaronder gpt-4o-audio-preview.

In ons geval moeten we OPENAI_API_KEY instellen. Je kunt dit elke keer handmatig doen wanneer je aan je project werkt, of een .env-bestand gebruiken om het makkelijk op te slaan. We bekijken beide methoden.

Methode 1: Omgevingsvariabelen handmatig instellen

Als je tijdelijk werkt en snel aan de slag wilt, kun je de omgevingsvariabele direct in je terminal zetten.

• Op macOS/Linux: export OPENAI_API_KEY='your-api-key-here'
• Op Windows gebruik je: set OPENAI_API_KEY='your-api-key-here'

Je API-sleutel is nu beschikbaar in je script en je kunt deze benaderen met de os-module in Python.

Methode 2: Een .env-bestand gebruiken

Als je een meer permanente oplossing wilt, kun je een .env-bestand gebruiken om je omgevingsvariabelen op te slaan. Dit bestand staat in je projectmap en houdt je sleutels veilig.

Maak eerst een .env-bestand in je projectmap en voeg daarin je API-sleutel als volgt toe:

OPENAI_API_KEY=your-api-key-hereMogelijk gemaakt door

Installeer vervolgens het pakket python-dotenv:

pip install python-dotenvMogelijk gemaakt door

Laad nu in je Python-script de omgevingsvariabelen uit het .env-bestand als volgt:

from dotenv import load_dotenv
import os
load_dotenv()  # Load variables from .env file
api_key = os.getenv('OPENAI_API_KEY')Mogelijk gemaakt door

Deze methode is vooral handig als je meerdere omgevingsvariabelen moet beheren en houdt je code schoon en veilig.

Optioneel: LangSmith voor tracing

Als je je API-calls wilt volgen en monitoren voor debugging of prestatieanalyse, heeft OpenAI een handige functie genaamd LangSmith. Het geeft je gedetailleerde logs van elke API-call van je model, wat superhandig is als je je workflow wilt optimaliseren of problemen wilt oplossen.

Je kunt LangSmith-tracing zo inschakelen:

os.environ["LANGSMITH_API_KEY"] = getpass.getpass("Enter your LangSmith API key: ")
os.environ["LANGSMITH_TRACING"] = "true"Mogelijk gemaakt door

Dit is volledig optioneel, maar een handig hulpmiddel als je aan een complexe applicatie werkt en wilt monitoren hoe je modellen zich gedragen.

OpenAI’s gpt-4o-audio-preview-model initialiseren

Nu onze omgeving is ingericht en klaar is, kunnen we aan het leuke deel beginnen—het initialiseren van OpenAI’s gpt-4o-audio-preview-model. Hier gaan we met het model interactie hebben, verzoeken doen en invoer en uitvoer verwerken.

In deze sectie lopen we door hoe je het model initialiseert met het LangChain-framework, een paar basisparameters aanpast en alles instelt om te starten met het genereren van reacties.

Wat betekent het model initialiseren?

Voor we in de code duiken, even kort wat "initialiseren" van het model betekent. We maken in feite een object in Python aan waarmee we met het gpt-4o-audio-preview-model kunnen communiceren. Dit object is als het bedieningspaneel—het bevat alle instellingen, configuraties en methoden die we nodig hebben om data naar het model te sturen en resultaten terug te krijgen.

Basisset-up van het model met LangChain

Laten we dit modelobject aanmaken. Omdat we binnen het LangChain-framework werken, gebruiken we de klasse ChatOpenAI uit het pakket langchain_openai. Deze klasse geeft ons eenvoudige toegang tot de modellen van OpenAI en hun functionaliteit.

from langchain_openai import ChatOpenAI

# Create the model object
llm = ChatOpenAI(
    model="gpt-4o-audio-preview",  # Specifying the model
    temperature=0,  # Controls randomness in the output
    max_tokens=None,  # Unlimited tokens in output (or specify a max if needed)
    timeout=None,  # Optional: Set a timeout for requests
    max_retries=2  # Number of retries for failed requests
)Mogelijk gemaakt door

Een groot voordeel van dit model is hoe aanpasbaar het is. Je kunt de parameters afstemmen op wat je nodig hebt. Als je bijvoorbeeld een app bouwt die audio moet transcriberen, kun je de parameters aanpassen om grotere input aan te kunnen of de uitvoerlengte te beperken.

Als je met tijdkritische verzoeken werkt en wilt voorkomen dat het model te lang bezig is, kun je ook een timeout instellen:

llm = ChatOpenAI(
    model="gpt-4o-audio-preview",
    timeout=30  # Set timeout to 30 seconds
)Mogelijk gemaakt door

Gpt-4o-audio-preview met audio-invoer en -uitvoer

Nu we het gpt-4o-audio-preview-model werkend hebben, gaan we in op de mogelijkheid om met audio-invoer en -uitvoer te werken.

Audio-bestanden uploaden en encoderen

Voordat je met audio kunt werken, is de eerste stap het laden en encoderen van je audiobestand in een formaat dat het model begrijpt. OpenAI verwacht dat audiodata in base64-gecodeerd formaat wordt verzonden, dus we beginnen met een bestand uploaden en encoderen.

Stel dat je een .wav-bestand hebt dat je door het model wilt laten verwerken—ik heb het gpt.wav genoemd. Je kunt dit vervangen door jouw bestand met de volgende code. Zo laad en bereid je dat bestand voor:

import base64

# Open the audio file and convert to base64
with open("gpt.wav", "rb") as f:
   audio_data = f.read()

# Convert binary audio data to base64
audio_b64 = base64.b64encode(audio_data).decode()Mogelijk gemaakt door

Wat gebeurt hier? We lezen het audiobestand als binaire data (modus "rb") en gebruiken vervolgens de base64-bibliotheek om het te encoderen naar een base64-tekenreeks. Dit is het formaat dat OpenAI vereist voor het verwerken van audio-invoer.

Audio naar het model sturen voor transcriptie

Zodra je audio is gecodeerd, is het tijd om deze aan het model door te geven. Het gpt-4o-audio-preview-model kan spraak uit audiobestanden transcriberen—dus als je ooit een podcast, voicememo of vergaderopname naar tekst wilde omzetten, is dit precies wat je nodig hebt! Zo werkt het.

# Define the input message with audio
messages = [
    (
        "human",
        [
            {"type": "text", "text": "Transcribe the following:"},
            {"type": "input_audio", "input_audio": {"data": audio_b64, "format": "wav"}},
        ],
    )
]

# Send the request to the model and get the transcription
output_message = llm.invoke(messages)
print(output_message.content)Mogelijk gemaakt door

In dit voorbeeld sturen we twee stukken data naar het model:

• Een tekstbericht met de instructie "Transcribe the following."
• De base64-gecodeerde audiodata met het formaat gespecificeerd als .wav.

Het model verwerkt deze invoer en retourneert een transcriptie van de audio. Als je audiobestand bijvoorbeeld een gesproken zin bevatte als "Ik leer hoe ik AI moet gebruiken", dan geeft het model een tekstuitvoer terug zoals: "I'm learning how to use AI."

Audio-uitvoer genereren met gpt-4o-audio-preview

Maar het gpt-4o-audio-preview-model draait niet alleen om audio begrijpen—het kan ook audio genereren. Zo configureer je het model om audio-uitvoer te genereren:

llm = ChatOpenAI(
    model="gpt-4o-audio-preview",
    temperature=0,
    model_kwargs={
        "modalities": ["text", "audio"],  # We’re telling the model to handle both text and audio
        "audio": {"voice": "alloy", "format": "wav"},  # Configure voice and output format
    }
)

# Send a request and ask the model to respond with audio
messages = [("human", "Are you human? Reply either yes or no.")]
output_message = llm.invoke(messages)

# Access the generated audio data
audio_response = output_message.additional_kwargs['audio']['data']Mogelijk gemaakt door

Laten we dit even ontleden:

• modalities=["text", "audio"]: We geven aan dat het model zowel tekst als audio moet verwerken. Hierdoor kan het gesproken reacties genereren.
• audio={"voice": "alloy", "format": "wav"}: Hier specificeren we de stem (in dit geval "alloy") en het formaat waarin we de audio-uitvoer willen (.wav). OpenAI biedt verschillende stemmen, dus je kunt de ervaring aanpassen aan de behoeften van je app.

De base64-gecodeerde audiorespons wordt opgeslagen in output_message.additional_kwargs['audio']['data'], en je kunt dit eenvoudig decoderen en opslaan voor weergave.

Audiobestanden opslaan en afspelen

Nu je audio genereert, wil je het bestand waarschijnlijk opslaan en afspelen, toch? Zo zet je die base64-gecodeerde audiodata om en sla je het op als een .wav-bestand:

# Decode the base64 audio data
audio_bytes = base64.b64decode(output_message.additional_kwargs['audio']['data'])

# Save the audio file
with open("output.wav", "wb") as f:
    f.write(audio_bytes)
print("Audio saved as output.wav")Mogelijk gemaakt door

Dit .wav-bestand kun je nu op je lokale machine afspelen met elke mediaspeler. Wanneer je het model aanroept, genereert het dus niet alleen een tekstreactie maar ook een audiobestand dat de reactie uitspreekt.

Geavanceerde use-cases van gpt-4o-audio-preview

In deze sectie laat ik zien hoe je tools koppelt aan het gpt-4o-audio-preview-model, complexere workflows afhandelt en zelfs meerdere stappen aan elkaar rijgt om volledig geautomatiseerde oplossingen te bouwen. Als je ooit een spraakassistent wilde bouwen die niet alleen audio transcribeert maar ook informatie uit externe bronnen ophaalt, dan helpt deze sectie je op weg.

Tools aanroepen

We beginnen met tool calling. Dit is je AI-model leren hoe het externe tools of functies kan gebruiken om zijn capaciteiten te verbeteren. In plaats van alleen tekst of audio te verwerken, kan het model extra taken uitvoeren zoals data ophalen uit API’s, berekeningen doen of zelfs het weer opzoeken.

OpenAI’s gpt-4o-audio-preview-model kan worden gecombineerd met andere tools en functies via LangChain’s bind_tools-methode. Met deze methode kun je een soepele workflow maken waarin het model beslist wanneer en hoe de door jou aangeleverde tools worden gebruikt.

Ik loop je door een praktisch voorbeeld van een tool aan het model koppelen. In dit geval koppelen we een tool die het weer ophaalt.

Eerst definiëren we een Pydantic-model dat de tool representeert die we willen gebruiken. Vervolgens koppelen we die tool aan het gpt-4o-audio-preview-model zodat deze kan worden aangeroepen wanneer nodig. Hiervoor heb je een API-sleutel van OpenWeatherMap nodig.

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)Mogelijk gemaakt door

Wat gebeurt hier precies:

• De tool definiëren: We definiëren een tool genaamd GetWeather, die een locatie als invoer neemt en met de OpenWeatherMap-API het actuele weer voor die locatie teruggeeft.
• Weer in Edinburgh ophalen: Dit keer halen we het weer op voor Edinburgh, VK.
• Realtime weerdata: De tool haalt realtime weerdata op via een externe API en geeft die terug.

In dit voorbeeld wil ik het weer in Edinburgh weten. Toen ik het uitvoerde, kreeg ik deze output: The weather in Edinburgh, GB is broken clouds with a temperature of 13.48°C.

Taken ketenen: multi-step-workflows bouwen

Door taken aan elkaar te ketenen kun je multi-step-workflows maken die meerdere tools en modelaanroepen combineren om complexe verzoeken af te handelen. Stel je voor dat je assistent audio transcribeert en vervolgens een actie uitvoert voor de locatie die in de audio genoemd wordt. In dit voorbeeld koppelen we een audiotranscriptietaak aan een weeropvraag op basis van de getranscribeerde locatie.

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.")Mogelijk gemaakt door

De code in het kort:

• Audiotranscriptie: De gebruiker levert audio-invoer (gecodeerd in base64). Deze audio wordt naar het model gestuurd, dat de inhoud transcribeert. Bijvoorbeeld: de transcriptie kan "Edinburgh" zeggen.
• Weer opvragen: Na de transcriptie en het bepalen van de locatie roept het model de GetWeather-tool aan om het weer voor die locatie op te halen.
• Volledig geautomatiseerde workflow: Deze set-up creëert een geautomatiseerde multi-step-workflow waarin het model eerst begrijpt wat er in de audio is gezegd (transcriptie) en vervolgens op basis daarvan relevante weerdata ophaalt.

Voor dit voorbeeld gaf ik het model een audiobestand waarin ik zei: “Edinburgh”. Dit is de output die ik kreeg:Transcribed location: Edinburgh

Weather result: The weather in Edinburgh is broken clouds with a temperature of 13.47°C.

Gpt-4o-audio-preview fine-tunen

In sommige gevallen wil je het model fine-tunen om specifieke taken effectiever af te handelen. Als je bijvoorbeeld een applicatie bouwt die medische audio transcribeert, wil je wellicht dat het model medische termen en jargon goed begrijpt. OpenAI laat je het model fine-tunen door het te trainen op aangepaste datasets.

Zo pak je dat aan:

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)Mogelijk gemaakt door

Dit gebruikt een fijn-afgesteld model dat specifiek is getraind op medische audio, maar je kunt modellen ook fine-tunen voor andere use-cases, zoals juridische transcripties, klantservice-opnames of podcastbewerking. 

Praktisch voorbeeld: een spraakgestuurde assistent bouwen

Tot slot bekijken we een praktisch voorbeeld waarin we een spraakgestuurde assistent bouwen die gebruikersvragen via audio beluistert, een antwoord genereert en terugspreekt met audio. 

Workflow in stappen

Dit is de workflow die we volgen:

1. De gebruiker spreekt in een microfoon en de audio wordt opgenomen.
2. Het model transcribeert de audio.
3. De transcriptie wordt verwerkt om een antwoord te genereren.
4. Vervolgens genereert het model een audiorespons die voor de gebruiker kan worden afgespeeld.

Implementatie

Zo codeer je dit:

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")Mogelijk gemaakt door

Zo werkt het

In het kort werkt het zo:

• Audio-invoer: De gebruiker levert audio-invoer, zoals een vraag (bijv. "Tell me a math joke"). De audio wordt in base64 gecodeerd en naar de assistent gestuurd.
• Transcriptie: Het model transcribeert de audio naar tekst. Deze transcriptie is beschikbaar als je die wilt loggen of tonen.
• Antwoord genereren: Op basis van de transcriptie genereert het model een antwoord met zijn interne kennis (bijv. "The capital of France is Paris")
• Audio-uitvoer: Het antwoord wordt omgezet naar audioformaat. De audio wordt opgeslagen als een bestand (bijv. "response.wav"), dat je met elke audioplayer kunt afspelen.

Deze assistent is gemaakt voor conversaties via audio. Hij luistert naar de stem van de gebruiker, begrijpt de vraag en antwoordt vervolgens met zijn eigen stem. Deze set-up is ideaal om simpele spraakassistenten te bouwen, en je kunt hem later naar wens uitbreiden!

Conclusie

In deze tutorial hebben we OpenAI's gpt-4o-audio-preview-model verkend: de set-up, audio-invoer/-uitvoer, geavanceerde use-cases en zelfs het bouwen van een eenvoudige spraakassistent. Dit krachtige model biedt een solide basis voor het creëren van audio-gestuurde toepassingen voor de praktijk.

Wil je je praktische kennis van LangChain vergroten? Dan raad ik deze blogs aan:

• Gebruikersinterfaces bouwen voor AI-toepassingen met Streamlit en LangChain
• RAG met Llama 3.1 8B, Ollama en LangChain: tutorial
• LangChain-agents bouwen om taken in Python te automatiseren