LangChain और ChatOpenAI के साथ GPT-4o Audio Preview का उपयोग कैसे करें

वर्चुअल एनवायरनमेंट और डिपेंडेंसीज़

OpenAI के gpt-4o-audio-preview मॉडल का उपयोग करने से पहले, आइए आपके प्रोजेक्ट के लिए एक वर्चुअल एनवायरनमेंट सेट अप करें। इससे चीज़ें संगठित रहती हैं और डिपेंडेंसी कॉन्फ्लिक्ट नहीं होते—खासकर तब उपयोगी जब आप कई प्रोजेक्ट पर काम कर रहे हों।

वर्चुअल एनवायरनमेंट क्या है?

मान लें कि आपके पास दो अलग-अलग प्रोजेक्ट हैं। एक को किसी पैकेज के वर्ज़न 1.0 की आवश्यकता है, जबकि दूसरे को 2.0 चाहिए। अगर आप सब कुछ ग्लोबली इंस्टॉल करेंगे, तो कॉन्फ्लिक्ट्स होंगे।

वर्चुअल एनवायरनमेंट एक आइसोलेटेड वर्कस्पेस बनाता है—जैसे एक बुलबुला—जहाँ आप किसी विशेष प्रोजेक्ट के लिए जो भी इंस्टॉल करना चाहें, कर सकते हैं। जब आप अपने प्रोजेक्ट के लिए एनवायरनमेंट बनाते हैं, तो अब आपको सिस्टम के Python सेटअप या कॉन्फ्लिक्टिंग पैकेजेज़ को तोड़ने की चिंता नहीं रहती।

वर्चुअल एनवायरनमेंट बनाना और सक्रिय करना

आइए अपने प्रोजेक्ट के लिए वर्चुअल एनवायरनमेंट बनाकर शुरुआत करें। हम Python के इनबिल्ट venv मॉड्यूल का उपयोग करेंगे। हमें यह करना होगा:

1. अपने प्रोजेक्ट फ़ोल्डर पर जाएँ—यही वह जगह है जहाँ आप अपना एनवायरनमेंट रखना चाहते हैं। यदि आपके पास अभी प्रोजेक्ट फ़ोल्डर नहीं है, तो एक बना लें।
2. फ़ोल्डर के अंदर पहुँचने के बाद, अब वर्चुअल एनवायरनमेंट बनाना है। macOS या Linux पर python3 -m venv env चलाएँ। Windows पर यह इस तरह दिखता है python -m venv env।
1. ध्यान दें कि venv Python का वर्चुअल एनवायरनमेंट बनाने का टूल है, और env एनवायरनमेंट फ़ोल्डर का नाम है। आप इसे कुछ भी नाम दे सकते हैं: env, venv, my_project_env, आदि। इसे छोटा और सरल रखना अच्छा अभ्यास है।
3. अब जब आपने वर्चुअल एनवायरनमेंट बना लिया है, तो उसे सक्रिय करने का समय है। यह चरण महत्वपूर्ण है क्योंकि यह सुनिश्चित करता है कि आप जो भी पैकेज इंस्टॉल करेंगे, वे केवल इसी प्रोजेक्ट को प्रभावित करेंगे।
1. macOS या Linux पर इसे इस कमांड से सक्रिय करें: source env/bin/activate। Windows पर उपयोग करें: .\env\Scripts\activate

आप देखेंगे कि आपका टर्मिनल प्रॉम्प्ट env जैसा कुछ दिखाने लगेगा—यह संकेत है कि आप अपने वर्चुअल एनवायरनमेंट के अंदर काम कर रहे हैं। अब से, आप जो भी पैकेज इंस्टॉल करेंगे या कमांड चलाएँगे, वे इसी प्रोजेक्ट तक सीमित रहेंगे।

langchain-openai इंस्टॉल करना

एनवायरनमेंट सक्रिय होने के साथ, अब आवश्यक टूल्स इंस्टॉल करने का समय है। चूँकि हम OpenAI और LangChain के साथ काम कर रहे हैं, तो langchain-openai पैकेज इंस्टॉल करके शुरू करते हैं। यह पैकेज हमें OpenAI के मॉडलों के साथ इंटरेक्ट करने देगा।

अपने टर्मिनल में यह चलाएँ: pip install langchain-openai।

एनवायरनमेंट वेरिएबल्स सेट करना

अगला चरण यह सुनिश्चित करना है कि आपकी संवेदनशील जानकारी, जैसे कि API keys, आपकी स्क्रिप्ट में हार्ड-कोड न हो जाए। हम यह एनवायरनमेंट वेरिएबल्स सेट करके करेंगे।

सबसे पहले, आपको OpenAI के मॉडलों तक एक्सेस की आवश्यकता होगी। यदि आपने अभी तक नहीं किया है, तो OpenAI प्लेटफ़ॉर्म पर जाएँ और एक अकाउंट बनाएँ। साइन अप करने के बाद, आपको एक API की जेनरेट करनी होगी। यह API की OpenAI के मॉडलों, जिनमें gpt-4o-audio-preview भी शामिल है, तक पहुँच का आपका पास है।

हमारे मामले में, हमें OPENAI_API_KEY सेट करना होगा। आप इसे हर बार प्रोजेक्ट पर काम करते समय मैन्युअली सेट कर सकते हैं, या आसान एक्सेस के लिए .env फ़ाइल का उपयोग कर सकते हैं। आइए दोनों तरीकों पर नज़र डालते हैं।

तरीका 1: एनवायरनमेंट वेरिएबल्स मैन्युअली सेट करना

यदि आप अस्थायी रूप से काम कर रहे हैं और एक त्वरित सेटअप चाहते हैं, तो आप टर्मिनल में सीधे एनवायरनमेंट वेरिएबल सेट कर सकते हैं।

• macOS/Linux पर चलाएँ: export OPENAI_API_KEY='your-api-key-here'
• Windows पर उपयोग करें: set OPENAI_API_KEY='your-api-key-here'

अब आपकी API की आपकी स्क्रिप्ट में उपलब्ध है, और आप इसे Python में os मॉड्यूल का उपयोग करके एक्सेस कर सकते हैं।

तरीका 2: .env फ़ाइल का उपयोग करना

यदि आप अधिक स्थायी समाधान पसंद करते हैं, तो आप .env फ़ाइल का उपयोग करके अपने एनवायरनमेंट वेरिएबल्स स्टोर कर सकते हैं। यह फ़ाइल आपके प्रोजेक्ट फ़ोल्डर में रहेगी और आपकी keys सुरक्षित रखेगी।

सबसे पहले, अपने प्रोजेक्ट डायरेक्टरी में एक .env फ़ाइल बनाएँ, और अंदर अपनी API की इस तरह जोड़ें:

OPENAI_API_KEY=your-api-key-hereसंचालित द्वारा

अब python-dotenv पैकेज इंस्टॉल करें:

pip install python-dotenvसंचालित द्वारा

अब अपनी Python स्क्रिप्ट में, .env फ़ाइल से एनवायरनमेंट वेरिएबल्स इस तरह लोड करें:

from dotenv import load_dotenv
import os
load_dotenv()  # Load variables from .env file
api_key = os.getenv('OPENAI_API_KEY')संचालित द्वारा

यह तरीका खास तौर पर तब उपयोगी है जब आपको कई एनवायरनमेंट वेरिएबल्स मैनेज करने हों—यह आपके कोड को साफ़ और सुरक्षित रखता है।

वैकल्पिक: ट्रेसिंग के लिए LangSmith

यदि आप डिबगिंग या प्रदर्शन के उद्देश्य से अपनी API कॉल्स को ट्रैक और मॉनिटर करना चाहते हैं, तो OpenAI के पास LangSmith नाम की एक शानदार सुविधा है। यह आपके मॉडल द्वारा की गई हर API कॉल के विस्तृत लॉग देता है, जो आपके वर्कफ़्लो को ऑप्टिमाइज़ या ट्रबलशूट करने में बहुत मददगार हो सकता है।

आप LangSmith ट्रेसिंग को इस तरह सक्षम कर सकते हैं:

os.environ["LANGSMITH_API_KEY"] = getpass.getpass("Enter your LangSmith API key: ")
os.environ["LANGSMITH_TRACING"] = "true"संचालित द्वारा

फिर से, यह पूरी तरह वैकल्पिक है, लेकिन यदि आप किसी जटिल एप्लिकेशन पर काम कर रहे हैं और मॉडलों के व्यवहार की निगरानी करना चाहते हैं, तो यह एक उपयोगी टूल है।

OpenAI के gpt-4o-audio-preview मॉडल को इंस्टैंसिएट करना

अब जब हमारा एनवायरनमेंट सेट अप और तैयार है, तो मज़ेदार हिस्से पर आते हैं—OpenAI के gpt-4o-audio-preview मॉडल को इंस्टैंसिएट करना। यहीं से हम मॉडल के साथ इंटरेक्ट करना शुरू करेंगे, रिक्वेस्ट भेजेंगे, और इनपुट-आउटपुट प्रोसेस करेंगे।

इस खंड में, हम LangChain फ्रेमवर्क का उपयोग करके मॉडल को कैसे इंस्टैंसिएट करना है, कुछ बुनियादी पैरामीटर्स को कैसे कस्टमाइज़ करना है, और प्रतिक्रियाएँ जेनरेट करना शुरू करने के लिए ज़रूरी सेटअप कैसे करना है—यह सब देखेंगे।

मॉडल को इंस्टैंसिएट करना क्या होता है?

कोड में जाने से पहले, समझते हैं कि "इंस्टैंसिएट" करने का मतलब क्या है। जब हम कहते हैं कि हम मॉडल को इंस्टैंसिएट कर रहे हैं, तो हम मूल रूप से Python में एक ऑब्जेक्ट बना रहे होते हैं जो हमें gpt-4o-audio-preview मॉडल के साथ इंटरेक्ट करने देगा। यह ऑब्जेक्ट एक कंट्रोल पैनल की तरह है—इसमें वे सभी सेटिंग्स, कॉन्फ़िगरेशन और मेथड्स होते हैं जिनकी मदद से हम मॉडल को डेटा भेजते हैं और परिणाम प्राप्त करते हैं।

LangChain के साथ बेसिक मॉडल सेटअप

आइए इस मॉडल ऑब्जेक्ट को बनाकर शुरुआत करते हैं। चूँकि हम LangChain फ्रेमवर्क में काम कर रहे हैं, तो हम langchain_openai पैकेज की ChatOpenAI क्लास का उपयोग करेंगे। यह क्लास OpenAI मॉडलों और उनकी क्षमताओं तक आसान पहुँच देती है।

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
)संचालित द्वारा

इस मॉडल की एक बेहतरीन बात इसकी कस्टमाइज़ेबिलिटी है। आप अपनी ज़रूरत के अनुसार पैरामीटर्स समायोजित कर सकते हैं। उदाहरण के लिए, अगर आप ऐसा एप्लिकेशन बना रहे हैं जिसे ऑडियो ट्रांसक्रिप्शन चाहिए, तो आप बड़े इनपुट संभालने या आउटपुट की लंबाई सीमित करने के लिए पैरामीटर्स ट्यून कर सकते हैं।

मान लीजिए आप समय-संवेदनशील रिक्वेस्ट्स से निपट रहे हैं और चाहते हैं कि मॉडल अधिक समय न ले, तो आप टाइमआउट भी सेट कर सकते हैं:

llm = ChatOpenAI(
    model="gpt-4o-audio-preview",
    timeout=30  # Set timeout to 30 seconds
)संचालित द्वारा

ऑडियो इनपुट्स और आउटपुट्स के साथ gpt-4o-audio-preview

अब जब gpt-4o-audio-preview मॉडल चालू हो चुका है, तो आइए इसकी ऑडियो इनपुट और आउटपुट संभालने की क्षमता पर आते हैं।

ऑडियो फ़ाइलें अपलोड और एन्कोड करना

ऑडियो के साथ काम शुरू करने से पहले, पहला कदम है अपनी ऑडियो फ़ाइल को ऐसे फ़ॉर्मैट में लोड और एन्कोड करना जिसे मॉडल समझ सके। OpenAI अपेक्षा करता है कि ऑडियो डेटा base64-एन्कोडेड फ़ॉर्मैट में भेजा जाए, इसलिए हम फ़ाइल अपलोड कर उसे एन्कोड करने से शुरू करेंगे।

मान लें कि आपके पास एक .wav फ़ाइल है जिसे आप मॉडल से प्रोसेस कराना चाहते हैं—मैंने इसे gpt.wav नाम दिया है। आप निम्नलिखित कोड में इसे अपनी फ़ाइल से बदल सकते हैं। फ़ाइल को लोड और तैयार करने का तरीका इस प्रकार है:

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()संचालित द्वारा

यहाँ क्या हो रहा है? हम ऑडियो फ़ाइल को बाइनरी डेटा ("rb" मोड) में पढ़ रहे हैं, फिर base64 लाइब्रेरी का उपयोग कर इसे base64 स्ट्रिंग में एन्कोड कर रहे हैं। OpenAI को ऑडियो इनपुट प्रोसेस करने के लिए यही फ़ॉर्मैट चाहिए।

ट्रांसक्रिप्शन के लिए मॉडल को ऑडियो भेजना

एक बार ऑडियो एन्कोड हो जाए, तो इसे मॉडल को पास करने का समय है। gpt-4o-audio-preview मॉडल ऑडियो फ़ाइलों से स्पीच को ट्रांसक्राइब कर सकता है—तो यदि आपको कभी पॉडकास्ट, वॉइस मेमो या मीटिंग रिकॉर्डिंग को टेक्स्ट में बदलने की ज़रूरत पड़ी है, तो यही आपके लिए है! देखते हैं यह कैसे काम करता है।

# 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)संचालित द्वारा

इस उदाहरण में, हम मॉडल को दो चीज़ें भेज रहे हैं:

• एक टेक्स्ट मैसेज जो निर्देश देता है: "Transcribe the following."
• base64-एन्कोडेड ऑडियो डेटा, जिसका फ़ॉर्मैट .wav दिया गया है।

मॉडल इस इनपुट को प्रोसेस करता है और ऑडियो का ट्रांसक्रिप्शन लौटाता है। तो यदि आपकी ऑडियो फ़ाइल में कोई वाक्य बोला गया है, जैसे "I’m learning how to use AI," तो मॉडल इसका टेक्स्ट आउटपुट इस तरह देगा: "I'm learning how to use AI."

gpt-4o-audio-preview के साथ ऑडियो आउटपुट जेनरेट करना

लेकिन gpt-4o-audio-preview मॉडल केवल ऑडियो समझने तक सीमित नहीं है—यह ऑडियो जेनरेट भी कर सकता है। यहाँ बताया गया है कि आप मॉडल को ऑडियो आउटपुट जेनरेट करने के लिए कैसे कॉन्फ़िगर कर सकते हैं:

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']संचालित द्वारा

आइए इसे समझते हैं:

• modalities=["text", "audio"]: हम मॉडल को बता रहे हैं कि हमें वह टेक्स्ट और ऑडियो—दोनों संभाले। इससे यह बोले गए रिस्पॉन्स जेनरेट कर सकता है।
• audio={"voice": "alloy", "format": "wav"}: यहाँ हम वॉयस (इस मामले में "alloy") और आउटपुट फ़ॉर्मैट (.wav) निर्दिष्ट कर रहे हैं। OpenAI कई वॉयसेज़ देता है, इसलिए आप अपने ऐप की ज़रूरतों के अनुसार अनुभव को कस्टमाइज़ कर सकते हैं।

base64-एन्कोडेड ऑडियो रिस्पॉन्स output_message.additional_kwargs['audio']['data'] में रहता है, और आप इसे आसानी से डिकोड करके प्लेबैक के लिए सेव कर सकते हैं।

ऑडियो फ़ाइलों को सेव करना और चलाना

अब जब आप ऑडियो जेनरेट कर रहे हैं, तो आप शायद फ़ाइल को सेव करना और चलाना चाहेंगे, है ना? यहाँ बताया गया है कि आप base64-एन्कोडेड ऑडियो डेटा को डिकोड कर .wav फ़ाइल के रूप में कैसे सेव कर सकते हैं:

# 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")संचालित द्वारा

अब आप इस .wav फ़ाइल को अपनी लोकल मशीन पर किसी भी मीडिया प्लेयर से चला सकते हैं। तो अब, जब आप मॉडल को इनवोक करते हैं, तो यह केवल टेक्स्ट रिस्पॉन्स ही नहीं बल्कि उसी उत्तर को बोलकर बताने वाली एक ऑडियो फ़ाइल भी जेनरेट करता है।

gpt-4o-audio-preview के उन्नत उपयोग

इस खंड में, मैं बताऊँगा कि gpt-4o-audio-preview मॉडल से टूल्स कैसे बाँधें, अधिक जटिल वर्कफ़्लो कैसे हैंडल करें, और पूरी तरह स्वचालित समाधान बनाने के लिए कई चरणों को एक साथ कैसे चेन करें। यदि आप कभी ऐसा वॉयस असिस्टेंट बनाना चाहते थे जो केवल ऑडियो ट्रांसक्राइब ही नहीं करता बल्कि बाहरी स्रोतों से जानकारी भी लाता है, तो यह खंड उपयोगी होगा।

टूल कॉलिंग

टूल कॉलिंग से शुरू करते हैं। यह आपके AI मॉडल को बाहरी टूल्स या फ़ंक्शन्स का उपयोग करना सिखाना है ताकि इसकी क्षमताएँ बढ़ें। केवल टेक्स्ट या ऑडियो प्रोसेस करने के बजाय, मॉडल अतिरिक्त कार्य कर सकता है—जैसे APIs से डेटा फ़ेच करना, कैलकुलेशन करना, या वेदर जानकारी देखना।

OpenAI का gpt-4o-audio-preview मॉडल LangChain के bind_tools मेथड का उपयोग कर अन्य टूल्स और फ़ंक्शन्स के साथ जोड़ा जा सकता है। इस मेथड से आप एक स्मूथ वर्कफ़्लो बना सकते हैं जहाँ मॉडल यह तय करता है कि दिए गए टूल्स का उपयोग कब और कैसे करना है।

मैं आपको एक व्यावहारिक उदाहरण के माध्यम से टूल को मॉडल से बाँधना दिखाऊँगा। इस मामले में, हम ऐसा टूल बाँधने जा रहे हैं जो मौसम की जानकारी लाता है।

सबसे पहले, हम उस टूल का प्रतिनिधित्व करने वाला एक Pydantic मॉडल परिभाषित करते हैं। फिर, हम उस टूल को gpt-4o-audio-preview मॉडल से बाँधते हैं ताकि आवश्यक होने पर उसे कॉल किया जा सके। इसके लिए आपको OpenWeatherMap से एक API की की आवश्यकता होगी।

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)संचालित द्वारा

देखते हैं यहाँ क्या हो रहा है:

• टूल परिभाषित करना: हम GetWeather नाम का टूल परिभाषित करते हैं, जो इनपुट के रूप में लोकेशन लेता है और OpenWeatherMap API का उपयोग कर उस स्थान का मौजूदा मौसम लौटाता है।
• एडिनबर्ग में मौसम लाना: इस बार, हम एडिनबर्ग, UK के लिए मौसम ला रहे हैं।
• रियल-टाइम वेदर डेटा: टूल बाहरी API का उपयोग करके वास्तविक समय का मौसम डेटा लाता है और उसे लौटाता है।

इस उदाहरण में, मैं एडिनबर्ग का मौसम जानना चाहता हूँ। जब मैंने इसे चलाया, तो यह आउटपुट मिला: The weather in Edinburgh, GB is broken clouds with a temperature of 13.48°C.

टास्क्स चेन करना: मल्टी-स्टेप वर्कफ़्लो बनाना

टास्क्स को चेन करके, आप मल्टी-स्टेप वर्कफ़्लो बना सकते हैं जो कई टूल्स और मॉडल कॉल्स को जोड़कर जटिल रिक्वेस्ट्स को संभालता है। एक परिदृश्य सोचें जहाँ आप चाहते हैं कि आपका असिस्टेंट ऑडियो ट्रांसक्राइब करे और फिर ऑडियो में बताई गई लोकेशन के लिए कोई कार्रवाई करे। इस उदाहरण में, हम एक ऑडियो ट्रांसक्रिप्शन टास्क को ट्रांसक्राइब्ड लोकेशन के आधार पर वेदर लुकअप के साथ चेन करेंगे।

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.")संचालित द्वारा

आइए कोड को समझें:

• ऑडियो ट्रांसक्रिप्शन: उपयोगकर्ता base64 में एन्कोड किया ऑडियो इनपुट देता है। यह ऑडियो मॉडल को भेजा जाता है, जो कंटेंट को ट्रांसक्राइब करता है। उदाहरण के लिए, ट्रांसक्रिप्शन "Edinburgh" कह सकता है।
• वेदर लुकअप: ऑडियो ट्रांसक्राइब करने और लोकेशन निर्धारित करने के बाद, मॉडल GetWeather टूल को कॉल करता है ताकि उस लोकेशन का मौसम लाया जा सके।
• पूरी तरह स्वचालित वर्कफ़्लो: यह सेटअप एक स्वचालित मल्टी-स्टेप वर्कफ़्लो बनाता है जहाँ मॉडल पहले ऑडियो में कही बात (ट्रांसक्राइब करना) समझता है और फिर प्रासंगिक मौसम डेटा लाकर उस जानकारी पर कार्य करता है।

इस उदाहरण में, मैंने मॉडल को एक ऑडियो फ़ाइल दी जिसमें मैंने कहा: “Edinburgh”. मुझे यह आउटपुट मिला:Transcribed location: Edinburgh

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

gpt-4o-audio-preview का फाइन-ट्यूनिंग

कुछ मामलों में, आप मॉडल को विशेष कार्यों को अधिक प्रभावी ढंग से संभालने के लिए फाइन-ट्यून करना चाहेंगे। उदाहरण के लिए, यदि आप ऐसा एप्लिकेशन बना रहे हैं जो मेडिकल ऑडियो ट्रांसक्राइब करता है, तो आप चाहेंगे कि मॉडल मेडिकल शब्दावली और जार्गन को अच्छी तरह समझे। OpenAI आपको कस्टम डेटासेट पर ट्रेनिंग देकर मॉडल को फाइन-ट्यून करने देता है।

आइए देखें यह कैसे करते हैं:

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)संचालित द्वारा

यह एक ऐसे फाइन-ट्यून मॉडल का उपयोग करता है जिसे खास तौर पर मेडिकल ऑडियो के लिए ट्रेन किया गया है, लेकिन आप लीगल ट्रांसक्रिप्शन, कस्टमर सर्विस रिकॉर्डिंग्स, या पॉडकास्ट एडिटिंग जैसे अन्य उपयोग मामलों के लिए भी मॉडल्स को फाइन-ट्यून कर सकते हैं। 

व्यावहारिक उदाहरण: वॉयस-इनेबल्ड असिस्टेंट बनाना

अंत में, आइए एक व्यावहारिक उदाहरण देखें जहाँ हम एक वॉयस-इनेबल्ड असिस्टेंट बनाते हैं जो ऑडियो के जरिए उपयोगकर्ता के प्रश्न सुनता है, प्रतिक्रिया जेनरेट करता है, और ऑडियो में ही जवाब देता है। 

वर्कफ़्लो ब्रेकडाउन

हम यह वर्कफ़्लो अपनाने जा रहे हैं:

1. उपयोगकर्ता माइक्रोफोन में बोलता है, और ऑडियो कैप्चर होता है।
2. मॉडल ऑडियो को ट्रांसक्राइब करता है।
3. ट्रांसक्रिप्शन को प्रोसेस कर उत्तर जेनरेट किया जाता है।
4. फिर मॉडल ऐसा ऑडियो रिस्पॉन्स बनाता है जिसे उपयोगकर्ता को चलाकर सुनाया जा सके।

इम्प्लीमेंटेशन

आइए देखें इसे कोड में कैसे करें:

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")संचालित द्वारा

यह कैसे काम करता है

आइए समझते हैं यह कैसे काम करता है:

• ऑडियो इनपुट: उपयोगकर्ता ऑडियो इनपुट देता है, जैसे कोई प्रश्न पूछना (उदा., "मुझे कोई गणित से जुड़ा चुटकुला सुनाइए")। ऑडियो को base64 में एन्कोड कर असिस्टेंट को भेजा जाता है।
• ट्रांसक्रिप्शन: मॉडल ऑडियो को टेक्स्ट में ट्रांसक्राइब करता है। यदि आप चाहें, तो इस ट्रांसक्रिप्शन को लॉग या डिस्प्ले कर सकते हैं।
• रिस्पॉन्स जेनरेशन: ट्रांसक्रिप्शन के आधार पर, मॉडल अपने आंतरिक ज्ञान का उपयोग करके उत्तर जेनरेट करता है (उदा., "फ्रांस की राजधानी पेरिस है")
• ऑडियो आउटपुट: रिस्पॉन्स को ऑडियो फ़ॉर्मैट में बदला जाता है। ऑडियो एक फ़ाइल (उदा., "response.wav") के रूप में सेव होता है, जिसे किसी भी ऑडियो प्लेयर से उपयोगकर्ता को सुनाया जा सकता है।

यह असिस्टेंट ऑडियो के साथ बातचीत के लिए बना है। यह उपयोगकर्ता की आवाज़ सुनता है, प्रश्न समझता है, और फिर अपनी ही आवाज़ में उत्तर देता है। यह सेटअप सरल वॉयस असिस्टेंट बनाने के लिए बढ़िया है, और आवश्यकता होने पर आप बाद में इसे और उन्नत बना सकते हैं!

निष्कर्ष

इस ट्यूटोरियल में, हमने OpenAI के gpt-4o-audio-preview मॉडल का अध्ययन किया—सेटअप, ऑडियो इनपुट/आउटपुट, उन्नत उपयोग, और एक बेसिक वॉयस असिस्टेंट बनाना भी शामिल है। यह शक्तिशाली मॉडल वास्तविक दुनिया के ऑडियो-इनेबल्ड एप्लिकेशन बनाने के लिए एक मज़बूत आधार देता है।

यदि आप अपनी LangChain की व्यावहारिक समझ बेहतर करना चाहते हैं, तो मैं ये ब्लॉग्स सुझाता/सुझाती हूँ:

• Streamlit और LangChain का उपयोग करके AI एप्लिकेशन के लिए यूज़र इंटरफ़ेस कैसे बनाएं
• Llama 3.1 8B, Ollama, और Langchain के साथ RAG: ट्यूटोरियल
• Python में टास्क्स ऑटोमेट करने के लिए LangChain एजेंट बनाना