OpenAI की Audio API: एक गाइड और डेमो प्रोजेक्ट

OpenAI Audio API

OpenAI के इस नए रिलीज़ में तीन मॉडल शामिल हैं:

1. gpt-4o-mini-tts: एक टेक्स्ट-टू-ऑडियो मॉडल जो विभिन्न टोन और आवाज़ों के साथ टेक्स्ट से ऑडियो जनरेट करने में सक्षम है। इस टेक्स्ट-टू-स्पीच मॉडल की एक अच्छी विशेषता यह है कि हम विशेष टेक्स्ट निर्देश देकर आवाज़ के टोन और शैली को निर्देशित कर सकते हैं। यह उच्च स्तर का कस्टमाइज़ेशन लाता है, जिससे अनोखे और आपकी ज़रूरतों के अनुरूप वॉयस अनुभव बनाए जा सकते हैं। इसे आप OpenAI.fm पर आज़मा सकते हैं।
2.  gpt-4o-transcribe और gpt-4o-mini-transcribe: दो ऑडियो-टू-टेक्स्ट मॉडल जो बोली गई भाषा को लिखित टेक्स्ट में बदलने के लिए बनाए गए हैं। इनका मुख्य कार्य ऑडियो की अत्यधिक सटीक और भरोसेमंद ट्रांसक्रिप्शन प्रदान करना है। इन मॉडलों में वर्ड एरर रेट (WER) कम दिखती है, यानी ये पहले के समाधानों की तुलना में बोले गए शब्दों को पहचानने में कम गलतियाँ करते हैं।

इन नए मॉडलों की कीमतें निम्नलिखित हैं:

वॉयस असिस्टेंट प्रोजेक्ट

इस ट्यूटोरियल में, मैं आपको सीधे आपके टर्मिनल में AI वॉयस असिस्टेंट बनाना सिखाऊँगा। यह वॉयस असिस्टेंट मूल रूप से एक लोकप्रिय टेक्स्ट-आधारित AI मॉडल की तरह होगा, लेकिन पूरी तरह से बोले गए संवाद के ज़रिए इंटरैक्ट करेगा। कल्पना कीजिए कि आप सीधे अपने कंप्यूटर से बात कर सकें, कोई भी प्रश्न पूछें और लगभग तुरंत आवाज़ में जवाब प्राप्त करें।

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

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

भले ही OpenAI एक समर्पित Realtime API प्रदान करता है जो पूरी प्रक्रिया को सुव्यवस्थित करके इंटरैक्शन को बेहतर बना सकता है, हम एक अलग तरीका अपनाएँगे। Realtime API प्रभावशाली है और तेज़ इंटीग्रेशन चाहने वाले डेवलपर्स के लिए उपयुक्त है, लेकिन यह अक्सर अधिक महंगा होता है और कम लचीलापन देता है।

प्रत्येक चरण के लिए अलग-अलग कॉम्पोनेंट्स के साथ प्रोजेक्ट बनाने का चुनाव करके, हमें अपने AI असिस्टेंट को कस्टमाइज़ करने पर अधिक नियंत्रण मिलता है। यह तरीका हमें तय करने देता है कि कौन से मॉडल इस्तेमाल करने हैं—चाहे लक्ष्य सटीकता हो, गति हो, या प्रतिक्रिया के टोन की पसंद। इस तरह हमारा वॉयस असिस्टेंट केवल शक्तिशाली ही नहीं, बल्कि अत्यधिक अनुकूलित भी बनता है, जो विशिष्ट प्रोजेक्ट आवश्यकताओं में फिट हो सके।

यहाँ विकसित किया गया सारा कोड इस GitHub रिपॉज़िटरी में उपलब्ध है। 

Python सेटअप

शुरू करने के लिए, हम पहले audio-demo नामक एक नया Anaconda वातावरण सेट करेंगे। Anaconda के वातावरण हमें प्रत्येक प्रोजेक्ट के लिए अलग-अलग स्पेस बनाने देते हैं, जहाँ हम पैकेजों के विशिष्ट वर्शन बिना टकराव के इंस्टॉल कर सकते हैं। अपने कमांड-लाइन इंटरफ़ेस में निम्न कमांड चलाएँ:

conda create -n audio-demo -y python=3.9
conda activate audio-demo
pip install openai
pip install numpy
pip install dotenv
pip install sounddevice
pip install scipyसंचालित द्वारा

आइए देखें कि प्रत्येक कमांड और पैकेज क्या करता है:

1. एन्वायरनमेंट बनाना:

• conda create -n audio-demo -y python=3.9: यह कमांड audio-demo नाम का नया वातावरण Python 3.9 के साथ बनाता है। -y फ़्लैग बिना पूछे इंस्टॉलेशन को मंज़ूरी देता है।

2. एन्वायरनमेंट सक्रिय करना:

• conda activate audio-demo: नए बनाए गए audio-demo वातावरण को सक्रिय करता है ताकि हम इसी में काम कर सकें।

3. पैकेज इंस्टॉल करना:

• pip install openai: OpenAI लाइब्रेरी जो OpenAI के मॉडल्स और APIs तक आसान पहुँच देती है।
• pip install numpy: NumPy संख्यात्मक कम्प्यूटिंग के लिए आवश्यक लाइब्रेरी है।
• pip install dotenv: Dotenv .env फ़ाइल से environment variables लोड करने में मदद करता है, जिससे कॉन्फ़िगरेशन प्रबंधन आसान और सुरक्षित होता है।
• pip install sounddevice: Sounddevice सरल फ़ंक्शनों के माध्यम से ध्वनि रिकॉर्ड और प्ले करने देता है, जो Python में ऑडियो इनपुट और आउटपुट संभालने के लिए आदर्श है।
• pip install scipy: SciPy, NumPy पर आधारित है और वैज्ञानिक व तकनीकी कम्प्यूटिंग के लिए अतिरिक्त सुविधाएँ देता है, जैसे सिग्नल प्रोसेसिंग। हमारे मामले में, हम इसका उपयोग ऑडियो फ़ाइल सहेजने के लिए करेंगे।

हमारा audio-demo वातावरण तैयार होने के साथ, अब हम अपने ऐसे AI असिस्टेंट पर काम शुरू कर सकते हैं जो ऑडियो इनपुट्स को प्रोसेस कर सके। यह संरचित सेटअप स्वच्छ डेवलपमेंट स्पेस बनाए रखने में मदद करता है और सुनिश्चित करता है कि हमारे प्रोजेक्ट के लिए सभी निर्भरताएँ उपलब्ध हों।

OpenAI API की कुंजी सेटअप

OpenAI API का उपयोग करने के लिए हमें एक API कुंजी की आवश्यकता होगी। उनके API की-पेज पर जाएँ और "Generate new secret key" बटन पर क्लिक करके एक API कुंजी बनाएं। कुंजी कॉपी करें, .env नाम की फ़ाइल बनाएँ, और नीचे दिए प्रारूप में पेस्ट करें:

OPENAI_API_KEY=<paste_your_api_key_here>संचालित द्वारा

टेक्स्ट से ऑडियो उदाहरण

आइए एक Python स्क्रिप्ट बनाने के चरणों से गुज़रते हैं जो OpenAI की टेक्स्ट-टू-ऑडियो क्षमताओं का उपयोग करके टेक्स्ट को निजी स्पर्श के साथ स्पीच में बदलती है। हम अपना कोड text_to_audio.py नामक फ़ाइल में लिखेंगे, जो .env फ़ाइल वाले उसी फ़ोल्डर में होगी।

आवश्यक लाइब्रेरी इम्पोर्ट करें

सबसे पहले, हमें अपने स्क्रिप्ट के लिए आवश्यक लाइब्रेरीज़ इम्पोर्ट करनी होंगी:

import asyncio
from openai import AsyncOpenAI
from openai.helpers import LocalAudioPlayer
from dotenv import load_dotenvसंचालित द्वारा

आइए जल्दी से देखें कि इनमें से प्रत्येक इम्पोर्ट क्या करता है:

• asyncio: Python में asynchronous कोड लिखने के लिए आवश्यक लाइब्रेरी, जो स्ट्रीमिंग APIs के साथ काम करने में ज़रूरी है।
• AsyncOpenAI: OpenAI लाइब्रेरी का हिस्सा, जो OpenAI के APIs के साथ asynchronous रूप से इंटरैक्ट करने के टूल देता है।
• LocalAudioPlayer: OpenAI का यह हेल्पर हमें अपनी मशीन पर लोकली ऑडियो प्ले करने देता है।
• load_dotenv: .env फ़ाइल से environment variables लोड करता है, जहाँ हम अपने API की जैसे संवेदनशील विवरण रखते हैं।

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

अगला कदम है load_dotenv फ़ंक्शन के साथ .env फ़ाइल से हमारी API कुंजी लोड करना:

load_dotenv()संचालित द्वारा

यह सुनिश्चित करता है कि हमारी स्क्रिप्ट को API कुंजी तक सुरक्षित पहुँच मिले।

OpenAI इनिशियलाइज़ करें

OpenAI API के साथ इंटरैक्ट करना शुरू करने के लिए हम AsyncOpenAI का एक उदाहरण बनाएँगे:

openai = AsyncOpenAI()संचालित द्वारा

मुख्य फ़ंक्शन लिखें

अब हम अपना मुख्य फ़ंक्शन text_to_audio() परिभाषित करेंगे, जो OpenAI की टेक्स्ट-टू-ऑडियो सुविधा का उपयोग करके इनपुट प्रोसेस करेगा और प्राप्त ऑडियो प्ले करेगा:

async def text_to_audio(text, tone_and_style_instructions):
  async with openai.audio.speech.with_streaming_response.create(
    model="gpt-4o-mini-tts",
    voice="coral",
    input=text,
    instructions=tone_and_style_instructions,
    response_format="pcm",
  ) as response:
    await LocalAudioPlayer().play(response)संचालित द्वारा

आइए जल्दी से समझ लें कि ऊपर हमने क्या किया:

• हम स्पीच सिंथेसिस नियंत्रित करने के लिए model और voice पैरामीटर निर्धारित करते हैं। इस्तेमाल किया गया model gpt-4o-mini-tts है और चुनी गई आवाज़ "coral" है।
• response_format को "pcm" पर सेट किया गया है, जो ऑडियो प्रोसेसिंग के लिए उपयुक्त है।
• LocalAudioPlayer तब API द्वारा जनरेट किए गए ऑडियो रिस्पॉन्स को प्ले करता है।

फ़ंक्शन निष्पादित करें

हम स्क्रिप्ट को निम्न पंक्तियों के साथ पूरा करते हैं ताकि text_to_audio() फ़ंक्शन स्क्रिप्ट चलने पर निष्पादित हो:

if __name__ == "__main__":
  asyncio.run(text_to_audio("Hello world!", "Enthusiastic voice."))संचालित द्वारा

यह कोड ब्लॉक जाँचता है कि स्क्रिप्ट मुख्य मॉड्यूल के रूप में चल रही है या नहीं, और asynchronous लॉजिक को संभालने के लिए asyncio.run() का उपयोग करते हुए text_to_audio() चलाता है।

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

हम स्क्रिप्ट को निम्न कमांड से चला सकते हैं:

python text_to_audio.pyसंचालित द्वारा

पूरा कोड यहाँ मिल सकता है।

फ़ाइल से ऑडियो ट्रांसक्रिप्शन

इस खंड में, आइए OpenAI के ऑडियो ट्रांसक्रिप्शन टूल का उपयोग करके किसी ऑडियो फ़ाइल को टेक्स्ट में ट्रांसक्राइब करना सीखें। हमारी स्क्रिप्ट प्रक्रिया को तेज़ और कुशल बनाने के लिए ऑडियो फ़ाइलों को asynchronous ढंग से हैंडल करने के लिए डिज़ाइन की गई है। हम इसे audio_to_text.py नामक फ़ाइल में लागू करेंगे।

इम्पोर्ट्स और शुरुआती सेटअप पहले जैसे ही हैं, बस यहाँ हमें LocalAudioPlayer इम्पोर्ट करने की ज़रूरत नहीं है। यहाँ देखें कि हम ऑडियो फ़ाइल ट्रांसक्राइब करने वाला फ़ंक्शन कैसे लिख सकते हैं:

async def transcribe_audio(audio_filename = "audio.wav"):
  audio_file = await asyncio.to_thread(open, audio_filename, "rb")
  stream = await openai.audio.transcriptions.create(
    model="gpt-4o-mini-transcribe",
    file=audio_file,
    response_format="text",
    stream=True,
  )
  transcript = ""
  async for event in stream:
    if event.type == "transcript.text.delta":
      print(event.delta, end="", flush=True)
      transcript += event.delta
  print()
  audio_file.close()
  return transcriptसंचालित द्वारा

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

1. ऑडियो फ़ाइल खोलना:

• audio_file = await asyncio.to_thread(open, audio_filename, "rb"): यह पंक्ति ऑडियो फ़ाइल को बाइनरी रीड मोड ("rb") में खोलती है। asyncio.to_thread() मेथड इस फ़ाइल-खोलने वाले ऑपरेशन को अलग थ्रेड में चलने देता है, ताकि यह प्रोग्राम के अन्य हिस्सों को ब्लॉक न करे।

2. ट्रांसक्रिप्शन स्ट्रीम बनाना:

• stream = await openai.audio.transcriptions. create(...): यह पंक्ति ट्रांसक्रिप्शन API को कॉल करती है। 
• हम model पैरामीटर को gpt-4o-mini-transcribe सेट करते हैं, जो खास तौर पर ट्रांसक्रिप्शन टास्क के लिए बनाया गया है।
• file पैरामीटर में हमारी ओपन की गई ऑडियो फ़ाइल जाती है।
• response_format="text" API को ट्रांसक्रिप्शन टेक्स्ट के रूप में लौटाने के लिए कहता है।
• stream=True ट्रांसक्रिप्शन को रीयल-टाइम में स्ट्रीम करने के लिए उपयोग होता है, यानी जैसे ही ऑडियो का कोई हिस्सा प्रोसेस होता है, वह तुरंत मिल जाता है, जिससे प्रतिक्रिया तेज़ हो जाती है।

3. ट्रांसक्रिप्शन स्ट्रीम प्रोसेस करना:

• async for event in stream: स्ट्रीम से आते हुए इवेंट्स को पढ़ने के लिए लूप शुरू करता है।
• if event.type == "transcript.text.delta":: हर इवेंट टाइप की जाँच करता है और तब प्रोसेस करता है जब टाइप transcript.text.delta हो, जो बताता है कि ट्रांसक्रिप्शन का एक हिस्सा तैयार है।
• print(event.delta, end="", flush=True): उपलब्ध होते ही क्रमिक ट्रांसक्रिप्शन को प्रिंट करता है, जिससे आउटपुट रीयल-टाइम में मिले।

4. ऑडियो फ़ाइल बंद करना:

• audio_file.close(): ट्रांसक्रिप्शन पूरा होने पर सिस्टम संसाधन मुक्त करने के लिए फ़ाइल बंद कर देना अच्छा अभ्यास है।

main() फ़ंक्शन चलाकर, हम किसी ऑडियो फ़ाइल को कुशलतापूर्वक टेक्स्ट में बदल सकते हैं और स्ट्रीम्ड तरीके से प्रोसेस कर सकते हैं ताकि तुरंत फीडबैक मिल सके। यह सेटअप तेज़ ट्रांसक्रिप्शन की आवश्यकता या लंबी ऑडियो फ़ाइलों वाले अनुप्रयोगों के लिए आदर्श है।

आप इसे स्क्रिप्ट वाले फ़ोल्डर में एक ऑडियो फ़ाइल रखकर, audio.wav को अपनी फ़ाइल के नाम से बदलकर और यह कमांड चलाकर आज़मा सकते हैं:

python audio_to_text.pyसंचालित द्वारा

पूरा कोड यहाँ मिल सकता है।

माइक्रोफ़ोन से ऑडियो ट्रांसक्रिप्शन

क्योंकि हमारा लक्ष्य एक वॉयस असिस्टेंट बनाना है, इसलिए हमें उपयोगकर्ता के ऑडियो प्रॉम्प्ट को एक ऑडियो फ़ाइल में रिकॉर्ड करना होगा।

हम record.py नाम की नई फ़ाइल बनाएँगे जिसमें record_audio नाम का फ़ंक्शन होगा। यह फ़ंक्शन माइक्रोफ़ोन से ध्वनि कैप्चर करता है और उसे ऑडियो फ़ाइल के रूप में सहेजता है। हम इसके काम करने के विवरण में अधिक नहीं जाएँगे क्योंकि यह इस लेख का मुख्य फोकस नहीं है:

import sounddevice as sd
import numpy as np
import scipy.io.wavfile as wavfile

SAMPLE_RATE = 44100  # Sample rate in Hz

def record_audio():
    print("[INFO: Recording... Press <Enter> to stop]")
    audio_data = []  # Initialize a list to store audio frames
    def callback(indata, frames, time, status):
        audio_data.append(indata.copy())
    with sd.InputStream(samplerate=SAMPLE_RATE, channels=1, callback=callback, dtype='int16'):
        input()  # Wait for the user to press Enter to stop recording
    print("[INFO: Recording complete]")
    print()
    audio_data = np.concatenate(audio_data)  # Concatenate the list into a single array
    filename = "output.wav"
    wavfile.write(filename, SAMPLE_RATE, audio_data)
    return audio_dataसंचालित द्वारा

जब हम इस फ़ंक्शन को कॉल करेंगे, तो यह उपयोगकर्ता के माइक्रोफ़ोन से रिकॉर्डिंग शुरू कर देगा। यह तब तक इंतज़ार करेगा जब तक उपयोगकर्ता "Enter" नहीं दबाता, और फिर दिए गए फ़ाइलनाम के साथ ऑडियो सहेज देगा।

इसे परखने के लिए, हम ऊपर दिए गए ट्रांसक्रिप्शन फ़ंक्शन के साथ इसे जोड़कर उपयोगकर्ता द्वारा बोला गया संदेश ट्रांसक्राइब कर सकते हैं। इसके लिए हम record_and_transcribe.py नाम की नई फ़ाइल इस प्रकार बनाएँगे:

import asyncio
from audio_to_text import transcribe_audio
from audio_recorder import record_audio

async def main():
  record_audio("prompt.wav")
  await transcribe_audio("prompt.wav")

if __name__ == "__main__":
  asyncio.run(main())संचालित द्वारा

आप इसे python record_and_transcribe.py कमांड के साथ चला कर देख सकते हैं। स्क्रिप्ट तब तक आपकी बात रिकॉर्ड करेगी जब तक आप "Enter" नहीं दबाते और फिर आपने जो कहा उसका ट्रांसक्रिप्शन कर देगी।

ऑडियो असिस्टेंट बनाना

इस खंड में हम सब कुछ जोड़कर एक ऑडियो असिस्टेंट बनाएँगे। हम इसे audio_assistant.py नाम की नई फ़ाइल में निम्न चरणों का पालन करते हुए लागू करेंगे:

• उपयोगकर्ता का ऑडियो प्रॉम्प्ट record_audio() फ़ंक्शन से रिकॉर्ड करें।
• transcribe_audio() फ़ंक्शन से ऑडियो प्रॉम्प्ट को टेक्स्ट में बदलें।
• gpt-4o जैसे सामान्य टेक्स्ट-टू-टेक्स्ट मॉडल से उत्तर जनरेट करें।
• अंत में, text_to_audio() फ़ंक्शन का उपयोग करके टेक्स्टुअल उत्तर को ऑडियो में बदलें।
• इसे तब तक दोहराएँ जब तक उपयोगकर्ता बाहर न निकल जाए।

निम्न आरेख इसे दर्शाता है:

आगे पढ़ने से पहले मैं आपको इसे स्वयं बनाने की कोशिश करने के लिए प्रोत्साहित करता हूँ।

पहले, हम पहले से लागू किए गए फ़ंक्शनों को इम्पोर्ट करते हैं और OpenAI क्लाइंट इनिशियलाइज़ करते हैं।

# Import the functions we created
from text_to_audio import text_to_audio
from audio_to_text import transcribe_audio
from audio_recorder import record_audio

# Import other dependencies and initialize OpenAI
import asyncio
from openai import AsyncOpenAI
from dotenv import load_dotenv
load_dotenv()
openai = AsyncOpenAI()संचालित द्वारा

फिर, हमें उत्तर जनरेट करने के लिए एक फ़ंक्शन चाहिए। यह सामान्य OpenAI GPT API का उपयोग करता है, जैसे gpt-4o या कोई अन्य टेक्स्ट-टू-टेक्स्ट मॉडल। यदि आप इसमें नए हैं, तो आप यह GPT-4o API ट्यूटोरियल देख सकते हैं।

इस फ़ंक्शन का एक asynchronous इम्प्लीमेंटेशन यहाँ है:

async def get_answer(prompt):
  stream = await openai.chat.completions.create(
    model="gpt-4o",
    messages=[
      {"role": "user", "content": prompt}
    ],
    stream=True,
  )
  answer = ""
  async for chunk in stream:
    content = chunk.choices[0].delta.content
    if content is not None:
      answer += content
      print(content, end="", flush=True)
  print("\n\n")
  return answerसंचालित द्वारा

मुख्य लूप लागू करने के लिए, हम ऊपर बताए गए चरणों का पालन करते हैं:

async def main(tone_and_style_instructions):
  await text_to_audio("Hello, how can I help you today?", tone_and_style_instructions)
  while True:
    record_audio("prompt.wav")
    prompt = await transcribe_audio("prompt.wav")
    print()
    answer = await get_answer(prompt)
    await text_to_audio(answer, tone_and_style_instructions)संचालित द्वारा

अंत में, जब स्क्रिप्ट चलती है तो हम मुख्य लूप को रन करते हैं:

if __name__ == "__main__":
  tone_and_style_instructions = "Enthusiastic voice."
  asyncio.run(main(tone_and_style_instructions))संचालित द्वारा

यहाँ इसका डेमो है:

पूरा कोड यहाँ मिल सकता है।

आगे के सुधार

यदि हम असिस्टेंट का उपयोग जटिल टोन और शैली के निर्देशों के साथ करें, तो हमें शब्दों और टोन के बीच असंगति दिखाई दे सकती है। उदाहरण के लिए, OpenAI वेबसाइट से लिया गया "Emo Teenager" वॉयस के लिए निम्न निर्देश देखें:

tone_and_style_instructions = """
Tone: Sarcastic, disinterested, and melancholic, with a hint of passive-aggressiveness.
Emotion: Apathy mixed with reluctant engagement.
Delivery: Monotone with occasional sighs, drawn-out words, and subtle disdain, evoking a classic emo teenager attitude.
"""संचालित द्वारा

ऑडियो का वॉयस टोन इस शैली से मेल खाएगा, लेकिन get_answer() फ़ंक्शन द्वारा जनरेट किए गए उत्तर की टेक्स्ट सामग्री इसे ध्यान में नहीं रखेगी, जिससे थोड़ी असंगति हो सकती है। यहाँ एक उदाहरण है:

इसे दूर करने के लिए, हम get_answer() फ़ंक्शन में उपयोगकर्ता संदेश के साथ एक सिस्टम प्रॉम्प्ट जोड़ सकते हैं, जो यह बताता है कि जनरेट किया गया टेक्स्ट टोन और शैली के निर्देशों का पालन करे।

इसके लिए, हम tone_and_style_instructions को get_answer() फ़ंक्शन के दूसरे आर्ग्युमेंट के रूप में देते हैं और चैट रिक्वेस्ट में एक सिस्टम मैसेज जोड़कर संशोधित करते हैं:

async def get_answer(prompt, tone_and_style_instructions):
  stream = await openai.chat.completions.create(
    model="gpt-4o",
    messages=[
      {
        "role": "system", 
        "content": 
          f"""
          The text you generate is being used in a text-to-voice model.
          Make sure your answer matches the guidelines {tone_and_style_instructions}
          """
      },
      {"role": "user", "content": prompt}
    ],
    stream=True,
  )
  answer = ""
  async for chunk in stream:
    content = chunk.choices[0].delta.content
    if content is not None:
      answer += content
      print(content, end="", flush=True)
  print("\n\n")
  return answerसंचालित द्वारा

अब मॉडल इस तरह जवाब देता है:

जैसा कि आप देख सकते हैं, अब यह जो टेक्स्ट जनरेट करता है, वह टोन निर्देशों से मेल खाता है। पूरा कोड आपको यहाँ मिल जाएगा।

Agents API के साथ असिस्टेंट बनाना

पिछले उदाहरण में, हमने एक वॉइस असिस्टेंट बनाने के लिए वॉयस-टू-टेक्स्ट और टेक्स्ट-टू-वॉयस मॉडलों को मैन्युअली कॉल किया। ऐसा करते हुए, हमने OpenAI की वॉयस API से नए मॉडलों का स्पष्ट रूप से उपयोग करना सीखा।

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

यदि आप पहली बार एजेंट API का उपयोग कर रहे हैं, तो आप इस ट्यूटोरियल पर नज़र डालना चाहेंगे: OpenAI Agents SDK।

शुरू करने से पहले, हमें एक और डिपेंडेंसी इंस्टॉल करनी होगी:

pip install 'openai-agents[voice]'संचालित द्वारा

यह करने के बाद, हम वॉयस पाइपलाइन के साथ एक एजेंट चलाने के लिए आवश्यक सब कुछ इम्पोर्ट करके शुरू करते हैं:

from dotenv import load_dotenv
load_dotenv()
import asyncio
from agents import Agent
from agents.voice import (
    AudioInput,
    SingleAgentVoiceWorkflow,
    VoicePipeline,
    VoicePipelineConfig,
    TTSModelSettings,
)
from audio_recorder import record_audio
from audio_player import AudioPlayerसंचालित द्वारा

AudioPlayer किसी पैकेज का हिस्सा नहीं है। इसे एक लोकल फ़ाइल से इम्पोर्ट किया गया है और इसमें एक साधारण क्लास है जो हमें रियल टाइम में ऑडियो चलाने में मदद करती है। यह इसलिए ज़रूरी है क्योंकि VoicePipeline के साथ हमें ऑडियो टुकड़ा-दर-टुकड़ा मिलता है, और हम हर टुकड़े को प्राप्त होते ही चला देंगे। यहाँ audio_player.py फ़ाइल की सामग्री है:

import numpy as np
import sounddevice as sd
class AudioPlayer:
  def __enter__(self):
    self.stream = sd.OutputStream(samplerate=24000, channels=1, dtype=np.int16)
    self.stream.start()
    return self
  def __exit__(self, tp, val, tb):
    self.stream.close()
  def add_audio(self, audio_data):
    self.stream.write(audio_data)संचालित द्वारा

अगला कदम एक एजेंट बनाना है:

agent = Agent(
  name="Voice Assistant",
  instructions="You’re a helpful assistant speaking to a human.",
  model="gpt-4o-mini",
)संचालित द्वारा

यहाँ हमने जिन पैरामीटर्स का इस्तेमाल किया है, उनका विवरण:

• name: यह हम अपनी इच्छा से कुछ भी रख सकते हैं।
• instructions: ये निर्देश बताते हैं कि एजेंट क्या है। यह सिस्टम प्रॉम्प्ट की तरह काम करता है।
• model: उत्तर जनरेट करने के लिए उपयोग किया जाने वाला मॉडल।

एजेंट, पहले इम्प्लीमेंट किए गए get_answer() फ़ंक्शन की तरह काम करता है। इसे उस पाइपलाइन के हिस्से की तरह समझें, जो टेक्स्ट प्रॉम्प्ट का उत्तर देता है।

अब हम पाइपलाइन परिभाषित करते हैं। यहीं हम वॉइस से संबंधित सभी कॉन्फ़िगरेशन तय करते हैं:

pipeline = VoicePipeline(
  workflow=SingleAgentVoiceWorkflow(agent),
  stt_model="gpt-4o-mini-transcribe",
  tts_model="gpt-4o-mini-tts",
  config=VoicePipelineConfig(
    tts_settings=TTSModelSettings(
      voice="coral",
      instructions="""
        Speak in an enthusiastic voice.
      """
    )
  )
)संचालित द्वारा

कुछ पैरामीटर्स का विवरण:

• stt_model: स्पीच को टेक्स्ट में बदलने के लिए उपयोग किया जाने वाला मॉडल।
• tts_model: टेक्स्ट को स्पीच में बदलने के लिए उपयोग किया जाने वाला मॉडल।
• config: पाइपलाइन कॉन्फ़िगरेशन दें। यहाँ हम इसका उपयोग tts_model के लिए चुनी जाने वाली आवाज़ और स्पीच निर्देश तय करने के लिए करते हैं।

अंत में, हम मुख्य लूप चलाते हैं, ठीक वैसे ही जैसे पहले किया था:

async def main():
  while True:
    audio_input = AudioInput(buffer=record_audio())
    result = await pipeline.run(audio_input)
    with AudioPlayer() as player:
      async for event in result.stream():
        if event.type == "voice_stream_event_audio":
          player.add_audio(event.data)

if __name__ == "__main__":
    asyncio.run(main())संचालित द्वारा

एक संपूर्ण इम्प्लीमेंटेशन आपको यहाँ मिल जाएगा।

टूल्स जोड़ना

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

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

from agents import function_tool
@function_tool
def stop_conversation():
  """Stop the conversation."""
  exit()संचालित द्वारा

फिर, हम यह टूल एजेंट को देते हैं:

agent = Agent(
  …
  tools=[stop_conversation], # Add this line when creating the agent
)संचालित द्वारा

इस इम्प्लीमेंटेशन के साथ, अगर हम कहें, “मैं बातचीत बंद करना चाहता/चाहती हूँ,” तो एजेंट समझ जाएगा कि उसे stop_conversation() फ़ंक्शन कॉल करना है। ध्यान दें कि यह इम्प्लीमेंटेशन, stop_conversation() फ़ंक्शन के लिखे जाने के तरीके के कारण, ग्रेसफुली एग्ज़िट नहीं करेगा।

यदि आप एक पूरा स्क्रिप्ट चाहते हैं तो यह फ़ाइल देखें।

एकाधिक एजेंट्स का उपयोग

एजेंट्स API की एक अच्छी विशेषता यह है कि हम एक साथ काम करने के लिए कई एजेंट्स को कॉन्फ़िगर कर सकते हैं। यहाँ एक उदाहरण है, जो OpenAI प्रलेखन से लिया गया है:

from agents.extensions.handoff_prompt import prompt_with_handoff_instructions

spanish_agent = Agent(
  name="Spanish voice assistant",
  handoff_description="A spanish speaking agent.",
  instructions=prompt_with_handoff_instructions(
    "You're speaking to a human, so be polite and concise. Speak in Spanish.",
  ),
  model="gpt-4o-mini",
)

agent = Agent(
  name="Voice Assistant",
  instructions=prompt_with_handoff_instructions("""
    You're speaking to a human, so be polite and concise. 
    If the user speaks in Spanish, handoff to the spanish agent.
  """),
  model="gpt-4o-mini",
)संचालित द्वारा

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

पूरा स्क्रिप्ट यहाँ उपलब्ध है।

निष्कर्ष

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