LangChain ve ChatOpenAI ile GPT-4o Audio Preview Nasıl Kullanılır

Sanal Ortam ve Bağımlılıklar

OpenAI'nin gpt-4o-audio-preview modelini kullanmadan önce, projeniz için bir sanal ortam oluşturalım. Bu, işleri düzenli tutar ve özellikle birden fazla projeyle çalışırken faydalı olan bağımlılık çakışmalarını önler.

Sanal ortam nedir?

İki farklı projeniz olduğunu düşünün. Bunlardan biri bir paketin 1.0 sürümünü, diğeri ise 2.0 sürümünü gerektiriyor. Her şeyi global olarak yüklerseniz, çakışmalarla karşılaşırsınız.

Sanal ortamlar, belirli bir proje için ihtiyaç duyduğunuz her şeyi yükleyebileceğiniz izole bir çalışma alanı—adeta bir balon—oluşturur. Projeniz için bir ortam oluşturduğunuzda, sisteminizin Python kurulumunu ya da çakışan paketleri bozma endişesi kalmaz.

Sanal ortamın oluşturulması ve etkinleştirilmesi

Başlayalım ve projemiz için bir sanal ortam oluşturalım. Python’un yerleşik venv modülünü kullanacağız. Şunları yapmamız gerekecek:

1. Proje klasörünüze gidin—ortamınızın bulunmasını istediğiniz yer burasıdır. Henüz bir proje klasörünüz yoksa bir tane oluşturun.
2. Klasörün içindeyken, sanal ortamı oluşturma zamanı. macOS veya Linux’ta python3 -m venv env komutunu çalıştırın. Windows’ta şu şekildedir: python -m venv env.
1. Burada venv, Python’un sanal ortam oluşturma aracıdır ve env ise ortam klasörünün adıdır. İsterseniz adı farklı olabilir: env, venv, my_project_env vb. Kısa ve basit tutmak iyi bir pratiktir.
3. Artık sanal ortamı oluşturduğunuza göre, onu etkinleştirme zamanı. Bu adım önemlidir; çünkü yüklediğiniz paketlerin yalnızca bu projeyi etkilemesini sağlar.
1. macOS veya Linux’ta şu komutla etkinleştirirsiniz: source env/bin/activate. Windows’ta kullanın: .\env\Scripts\activate

Terminal isteminizin env gibi bir şeye dönüştüğünü fark edeceksiniz—bu, sanal ortam içinde çalıştığınızın işaretidir. Bundan sonra yüklediğiniz paketler veya çalıştırdığınız komutlar bu projeyle sınırlı olacaktır.

langchain-openai’nin kurulumu

Ortamınızı etkinleştirdiğinize göre, ihtiyaç duyduğunuz araçları yükleme zamanı. OpenAI ve LangChain ile çalıştığımız için, langchain-openai paketini yükleyerek başlayalım. Bu paket, OpenAI’nin modelleriyle etkileşim kurmamıza olanak tanır.

Terminalinizde şunu çalıştırın: pip install langchain-openai.

Ortam değişkenlerinin ayarlanması

Sıradaki adım, API anahtarları gibi hassas bilgilerinizin betiklerinize sabitlenmemesini sağlamaktır. Bunu ortam değişkenleri ayarlayarak yapacağız.

Öncelikle, OpenAI’nin modellerine erişmeniz gerekir. Henüz yapmadıysanız, OpenAI platformuna gidip bir hesap oluşturun. Kayıt olduktan sonra bir API anahtarı üretmeniz gerekecek. Bu API anahtarı, gpt-4o-audio-preview dahil OpenAI’nin modellerine erişim geçişinizdir.

Bizim durumumuzda, OPENAI_API_KEY ayarlamamız gerekecek. Bunu her projede elle ayarlayabilir veya kolay erişim için bir .env dosyası kullanabilirsiniz. Her iki yönteme de bakalım.

Yöntem 1: Ortam değişkenlerini elle ayarlama

Eğer geçici olarak çalışıyor ve hızlı bir kurulum istiyorsanız, ortam değişkenini doğrudan terminalde ayarlayabilirsiniz.

• macOS/Linux’ta çalıştırın: export OPENAI_API_KEY='your-api-key-here'
• Windows’ta şunu kullanın: set OPENAI_API_KEY='your-api-key-here'

Artık API anahtarınız betiğinizde kullanılabilir ve Python’da os modülünü kullanarak ona erişebilirsiniz.

Yöntem 2: .env dosyası kullanma

Daha kalıcı bir çözüm tercih ediyorsanız, ortam değişkenlerinizi saklamak için bir .env dosyası kullanabilirsiniz. Bu dosya proje klasörünüzde bulunur ve anahtarlarınızı güvende tutar.

Önce, proje dizininizde bir .env dosyası oluşturun ve içine API anahtarınızı şu şekilde ekleyin:

OPENAI_API_KEY=your-api-key-hereAltyapı:

Şimdi python-dotenv paketini yükleyin:

pip install python-dotenvAltyapı:

Ardından, Python betiğinizde ortam değişkenlerini .env dosyasından şu şekilde yükleyin:

from dotenv import load_dotenv
import os
load_dotenv()  # Load variables from .env file
api_key = os.getenv('OPENAI_API_KEY')Altyapı:

Bu yöntem, yönetmeniz gereken birden çok ortam değişkeni varsa özellikle kullanışlıdır; kodunuzu temiz ve güvenli tutar.

İsteğe bağlı: İzleme için LangSmith

API çağrılarınızı hata ayıklama veya performans amacıyla izlemek ve takip etmek isterseniz, OpenAI’nin LangSmith adlı güzel bir özelliği var. Modeliniz tarafından yapılan her API çağrısının ayrıntılı günlüklerini sunar ve iş akışınızı optimize etmeye veya sorun gidermeye çalışıyorsanız çok yardımcı olabilir.

LangSmith izlemeyi şu şekilde etkinleştirebilirsiniz:

os.environ["LANGSMITH_API_KEY"] = getpass.getpass("Enter your LangSmith API key: ")
os.environ["LANGSMITH_TRACING"] = "true"Altyapı:

Yine tamamen isteğe bağlıdır; ancak karmaşık bir uygulama üzerinde çalışıyor ve modellerinizin nasıl davrandığını izlemek istiyorsanız kullanışlı bir araçtır.

OpenAI’nin gpt-4o-audio-preview Modelini Başlatma

Artık ortamımızı kurup hazır hale getirdiğimize göre, eğlenceli kısma geçme zamanı—OpenAI’nin gpt-4o-audio-preview modelini başlatmak. Burada modelle etkileşime başlayacak, istekler gönderecek ve girdileri/çıktıları işleyeceğiz.

Bu bölümde, modeli LangChain çerçevesini kullanarak nasıl başlatacağınızı, bazı temel parametreleri nasıl özelleştireceğinizi ve yanıt üretmeye başlamak için gerekli her şeyi nasıl kuracağınızı adım adım ele alacağız.

Modeli başlatmak ne anlama gelir?

Koda geçmeden önce, “modeli başlatmak” ifadesinin ne anlama geldiğini kısaca açıklayalım. Bir modeli başlattığımızda, Python’da gpt-4o-audio-preview modeliyle etkileşime geçmemizi sağlayacak bir nesne oluşturuyoruz. Bu nesne bir kontrol paneli gibidir—modele veri göndermek ve sonuç almak için ihtiyaç duyacağımız tüm ayarları, yapılandırmaları ve yöntemleri barındırır.

LangChain ile temel model kurulumu

Bu model nesnesini oluşturarak başlayalım. LangChain çerçevesinde çalıştığımız için, langchain_openai paketindeki ChatOpenAI sınıfını kullanacağız. Bu sınıf, OpenAI modellerine ve işlevlerine kolay erişim sunar.

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
)Altyapı:

Bu modelin en iyi yanlarından biri, ne kadar özelleştirilebilir olduğudur. İhtiyaçlarınıza göre parametreleri ayarlayabilirsiniz. Örneğin, ses transkripsiyonu gerektiren bir uygulama geliştiriyorsanız, daha büyük girdileri işlemek veya çıktı uzunluğunu sınırlamak için parametreleri değiştirebilirsiniz.

Örneğin, zaman açısından kritik isteklerle uğraşıyorsanız ve modelin çok uzun sürmemesini istiyorsanız, bir zaman aşımı da ayarlayabilirsiniz:

llm = ChatOpenAI(
    model="gpt-4o-audio-preview",
    timeout=30  # Set timeout to 30 seconds
)Altyapı:

Ses Girdileri ve Çıktılarıyla gpt-4o-audio-preview

Artık gpt-4o-audio-preview modelini çalıştırdığımıza göre, ses girdilerini ve çıktıları işleme yeteneğine geçelim.

Ses dosyalarının yüklenmesi ve kodlanması

Sese başlamadan önce ilk adım, ses dosyanızı modelin anlayabileceği bir biçime yüklemek ve kodlamaktır. OpenAI, ses verilerinin base64 kodlu biçimde gönderilmesini bekler; bu nedenle bir dosya yükleyip onu kodlayarak başlayacağız.

Diyelim ki modelin işlemesini istediğiniz bir .wav dosyanız var—ben gpt.wav adını verdim. Aşağıdaki kodu kullanarak bunu kendi dosyanızla değiştirebilirsiniz. Dosyayı nasıl yükleyip hazırlayacağınız şöyle:

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()Altyapı:

Burada ne oluyor? Ses dosyasını ikili veri olarak ("rb" modu) okuyor, sonra base64 kitaplığını kullanarak base64 dizgesine kodluyoruz. Bu, OpenAI’nin ses girdilerini işlemek için gerektirdiği biçimdir.

Transkripsiyon için sesi modele gönderme

Ses dosyanız kodlandıktan sonra, onu modele iletme zamanı. gpt-4o-audio-preview modeli, ses dosyalarından konuşmayı metne dökebilir—yani bir podcast’i, sesli notu veya toplantı kaydını metne çevirmeniz gerektiğinde tam da aradığınız şey! Nasıl çalıştığına bakalım.

# 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)Altyapı:

Bu örnekte modele iki veri parçası gönderiyoruz:

• "Transcribe the following." talimatını veren bir metin mesajı.
• Biçimi .wav olarak belirtilmiş base64 kodlu ses verisi.

Model bu girdiyi işler ve sesin transkripsiyonunu döndürür. Örneğin ses dosyanızda “Yapay zekâyı nasıl kullanacağımı öğreniyorum” gibi bir cümle varsa, model şu gibi bir metin çıktısı döndürür: "I'm learning how to use AI."

gpt-4o-audio-preview ile ses çıktıları üretme

Ancak gpt-4o-audio-preview modeli yalnızca sesi anlamakla kalmaz—aynı zamanda ses de üretebilir. İşte modeli ses çıktıları üretecek şekilde nasıl yapılandırabileceğiniz:

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']Altyapı:

Bunu açalım:

• modalities=["text", "audio"]: Modele hem metin hem de sesle ilgilenmesini söylediğimizi belirtir. Bu, konuşulan yanıtlar üretebilmesini sağlar.
• audio={"voice": "alloy", "format": "wav"}: Burada sesi (bu örnekte "alloy") ve ses çıktısını istediğimiz biçimi (.wav) belirtiyoruz. OpenAI birden fazla ses seçeneği sunar; böylece uygulamanızın ihtiyaçlarına göre deneyimi özelleştirebilirsiniz.

Base64 kodlu ses yanıtı output_message.additional_kwargs['audio']['data'] içinde saklanır; bunu kolayca çözüp oynatmak üzere kaydedebilirsiniz.

Ses dosyalarını kaydetme ve oynatma

Artık ses ürettiğinize göre, dosyayı kaydedip oynatmak isteyeceksiniz, değil mi? İşte base64 kodlu ses verisini alıp çözüp bir .wav dosyası olarak nasıl kaydedebileceğiniz:

# 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")Altyapı:

Bu .wav dosyasını artık yerel makinenizde herhangi bir medya oynatıcı ile oynatabilirsiniz. Böylece modeli çağırdığınızda yalnızca bir metin yanıtı üretmekle kalmaz, aynı zamanda yanıtı seslendiren bir ses dosyası da oluşturur.

gpt-4o-audio-preview’un İleri Düzey Kullanım Alanları

Bu bölümde, gpt-4o-audio-preview modeline araç bağlamayı, daha karmaşık iş akışlarını ele almayı ve hatta tamamen otomatik çözümler oluşturmak için birden çok adımı zincirlemeyi anlatacağım. Yalnızca sesi transkribe etmekle kalmayıp dış kaynaklardan bilgi de getiren bir sesli asistan oluşturmak istediyseniz, bu bölüm faydalı olacaktır.

Araç çağırma

Önce araç çağırmadan başlayalım. Bu, yapay zekâ modelinize yeteneklerini geliştirmek için harici araçları veya işlevleri nasıl kullanacağını öğretmektir. Model, yalnızca metin veya ses işlemek yerine API’lerden veri çekmek, hesaplamalar yapmak veya hatta hava durumunu sorgulamak gibi ek görevler gerçekleştirebilir.

OpenAI’nin gpt-4o-audio-preview modeli, LangChain’in bind_tools yöntemi kullanılarak diğer araçlar ve işlevlerle birleştirilebilir. Bu yöntemle, modelin sağladığınız araçları ne zaman ve nasıl kullanacağına karar verdiği akıcı bir iş akışı oluşturabilirsiniz.

Modelle bir aracı bağlamanın pratik bir örneğini adım adım göstereceğim. Bu durumda, hava durumu getiren bir aracı bağlayacağız.

Önce, kullanmak istediğimiz aracı temsil eden bir Pydantic modeli tanımlarız. Ardından, bu aracı gerektiğinde çağrılabilmesi için gpt-4o-audio-preview modeline bağlarız. Bunun için OpenWeatherMap’ten bir API anahtarı gerekecektir.

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)Altyapı:

Burada neler olduğuna bakalım:

• Aracın tanımlanması: GetWeather adlı bir araç tanımlıyoruz; bu araç bir konumu giriş olarak alır ve OpenWeatherMap API’sini kullanarak o konumun güncel hava durumunu döndürür.
• Edinburgh için hava durumu çekme: Bu örnekte, Birleşik Krallık’taki Edinburgh için hava durumunu alıyoruz.
• Gerçek zamanlı hava verisi: Araç, harici bir API kullanarak gerçek zamanlı hava verisini çeker ve döndürür.

Bu örnekte özel olarak Edinburgh’un hava durumunu bilmek istedim. Çalıştırdığımda şu çıktıyı aldım: The weather in Edinburgh, GB is broken clouds with a temperature of 13.48°C.

Görevleri zincirlemek: Çok adımlı iş akışları oluşturma

Görevleri zincirleyerek, karmaşık istekleri ele almak için birden çok aracı ve model çağrısını birleştiren çok adımlı iş akışları oluşturabilirsiniz. Asistanınızın sesi transkribe edip ardından seste geçen konum için bir eylem gerçekleştirmesini istediğiniz bir senaryoyu düşünün. Bu örnekte, bir ses transkripsiyonu görevini, transkribe edilen konuma dayalı hava durumu sorgusuyla zincirleyeceğiz.

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.")Altyapı:

Kodu adım adım inceleyelim:

• Ses transkripsiyonu: Kullanıcı bir ses girdisi (base64 kodlu) sağlar. Bu ses modele gönderilir ve içerik transkribe edilir. Örneğin, transkripsiyon “Edinburgh” diyebilir.
• Hava durumu sorgusu: Ses transkribe edildikten ve konum belirlendikten sonra, model o konum için hava durumunu almak üzere GetWeather aracını çağırır.
• Tamamen otomatik iş akışı: Bu kurulum, modelin önce seste söyleneni (transkripsiyon) anlamasını, ardından bu bilgiye göre ilgili hava verilerini getirerek harekete geçmesini sağlayan çok adımlı bir iş akışı oluşturur.

Bu örnekte modele “Edinburgh” dediğim bir ses dosyası verdim. Aldığım çıktı şuydu:Transcribed location: Edinburgh

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

gpt-4o-audio-preview’un İnce Ayarı

Bazı durumlarda, modelin belirli görevleri daha etkili şekilde ele alması için ince ayar yapmak isteyebilirsiniz. Örneğin, tıbbi sesleri transkribe eden bir uygulama geliştiriyorsanız, modelin tıbbi terimler ve jargon konusunda derin bir anlayışa sahip olmasını isteyebilirsiniz. OpenAI, modeli özel veri kümeleriyle eğiterek ince ayar yapmanıza olanak tanır.

Bunu nasıl yapacağımıza bakalım:

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)Altyapı:

Bu, özellikle tıbbi sesleri ele almak üzere eğitilmiş ince ayarlı bir modeli kullanır; ancak hukuki transkripsiyonlar, müşteri hizmetleri kayıtları veya podcast düzenleme gibi diğer kullanım senaryoları için de modelleri ince ayar yapabilirsiniz.

Uygulamalı Örnek: Ses Özellikli Bir Asistan Oluşturma

Son olarak, kullanıcının sorgularını ses üzerinden dinleyen, bir yanıt üreten ve yine sesle karşılık veren bir ses özellikli asistanı nasıl oluşturacağımızı gösteren pratik bir örneğe bakalım.

İş akışının kırılımı

Şu iş akışını takip edeceğiz:

1. Kullanıcı mikrofona konuşur ve ses yakalanır.
2. Model, sesi transkribe eder.
3. Transkripsiyon, bir yanıt üretmek üzere işlenir.
4. Model ardından kullanıcıya geri çalınabilecek bir sesli yanıt üretir.

Uygulama

Bunu nasıl kodlayacağımıza bakalım:

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")Altyapı:

Nasıl çalışır

Nasıl çalıştığını parçalayalım:

• Ses girişi: Kullanıcı bir ses girdisi sağlar; örneğin bir soru sorar (örn. “Bana bir matematik şakası söyle”). Ses base64’e kodlanır ve asistana iletilir.
• Transkripsiyon: Model sesi metne döker. Bu transkripsiyon, kaydetmek veya göstermek isterseniz kullanılabilir.
• Yanıt üretimi: Transkripsiyona dayanarak model, içsel bilgisini kullanarak bir yanıt üretir (örn. “Fransa’nın başkenti Paris’tir”).
• Ses çıktısı: Yanıt ses biçimine dönüştürülür. Ses “response.wav” gibi bir dosya olarak kaydedilir ve herhangi bir ses oynatıcı ile kullanıcıya geri çalınabilir.

Bu asistan, sesle konuşmak için tasarlanmıştır. Kullanıcının sesini dinler, soruyu anlar ve ardından kendi sesiyle yanıt verir. Bu kurulum, basit sesli asistanlar oluşturmak için harikadır; gerekirse daha sonra daha gelişmiş hale getirebilirsiniz!

Sonuç

Bu eğitimde, OpenAI'nin gpt-4o-audio-preview modelini; kurulum, ses girişi/çıkışı, ileri kullanım alanları ve temel bir sesli asistan oluşturma dahil olmak üzere ele aldık. Bu güçlü model, gerçek dünyada ses özellikli uygulamalar oluşturmak için sağlam bir temel sunar.

LangChain pratiğinizi geliştirmek isterseniz şu blogları öneririm:

• Streamlit ve LangChain Kullanarak Yapay Zekâ Uygulamaları İçin Kullanıcı Arayüzleri Nasıl Oluşturulur
• Llama 3.1 8B, Ollama ve LangChain ile RAG: Eğitim
• Python’da Görevleri Otomatikleştirmek İçin LangChain Ajanları Oluşturma