मॉडल्स

प्रमुख मॉडल्स

टेक्स्ट टू स्पीच

स्पीच टू टेक्स्ट

संगीत

मॉडल्स का अवलोकन

ElevenLabs API अलग-अलग उपयोग के मामलों, क्वालिटी स्तरों और परफ़ॉर्मेंस ज़रूरतों के लिए ऑप्टिमाइज़ किए गए कई ऑडियो मॉडल देता है।

अप्रचलित मॉडल्स

Eleven v4

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

यह मॉडल इन स्थितियों में अच्छा काम करता है:

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

Eleven v4 टेक्स्ट टू डायलॉग API के ज़रिए उपलब्ध है।

समर्थित भाषाएँ

Eleven v4 मॉडल परिवार 90+ भाषाओं को सपोर्ट करता है, जिनमें शामिल हैं:

अफ़्रीकान्स (afr), अम्हारिक (amh), अरबी (ara), आर्मेनियाई (hye), असमिया (asm), अस्तूरियाई (ast), अज़रबैजानी (aze), बेलारूसी (bel), बांग्ला (ben), बोस्नियाई (bos), बल्गेरियाई (bul), बर्मी (mya), कैंटोनीज़ (yue), कैटलन (cat), सेबुआनो (ceb), क्रोएशियाई (hrv), चेक (ces), डेनिश (dan), डच (nld), अंग्रेज़ी (eng), एस्टोनियाई (est), फ़िलिपीनो (fil), फ़िनिश (fin), फ़्रेंच (fra), फूला/पुलार (ful), गैलिशियन (glg), जॉर्जियाई (kat), जर्मन (deu), यूनानी (ell), गुजराती (guj), हौसा (hau), हिब्रू (heb), हिंदी (hin), हंगेरियाई (hun), आइसलैंडिक (isl), इंडोनेशियाई (ind), इतालवी (ita), जापानी (jpn), जावानीज़ (jav), कांबा (kam), कन्नड़ (kan), कज़ाख़ (kaz), कोरियाई (kor), किर्गिज़ (kir), लाओ (lao), लातवियाई (lav), लिंगाला (lin), लिथुआनियाई (lit), लुगांडा (lug), लक्ज़मबर्गिश (ltz), मैसिडोनियाई (mkd), मलय (msa), मलयालम (mal), माल्टीज़ (mlt), मंदारिन चीनी (cmn), माओरी (mri), मराठी (mar), मंगोलियाई (mon), नेपाली (nep), नॉर्वेजियन बोकमॉल (nob), ओक्सितान (oci), ओड़िया (ori), पश्तो (pus), फ़ारसी (fas), पोलिश (pol), पुर्तगाली, ब्राज़ील (por), पंजाबी (pan), रोमानियाई (ron), रूसी (rus), सर्बियाई (srp), शोना (sna), सिंधी (snd), स्लोवाक (slk), स्लोवेनियाई (slv), सोमाली (som), सोरानी कुर्दिश (ckb), स्पेनिश, लैटिन अमेरिका (spa), स्वाहिली (swa), स्वीडिश (swe), ताजिक (tgk), तमिल (tam), तेलुगु (tel), थाई (tha), तुर्की (tur), यूक्रेनी (ukr), उर्दू (urd), उज़्बेक (uzb), वियतनामी (vie), वेल्श (cym), वोलोफ़ (wol), ज़ुलू (zul)।

Eleven v4 Turbo

Eleven v4 Turbo रीयल-टाइम स्पीच सिंथेसिस के लिए हमारा अत्याधुनिक मॉडल है, जो उच्च क्वालिटी की ऑडियो, अभिव्यक्ति और वॉइस के प्रदर्शन पर नियंत्रण देता है। Eleven v4 Turbo हाई-फिडेलिटी वॉइस क्लोनिंग को सपोर्ट करता है और लगभग ~100ms की औसत अनुमान लेटेंसी में नतीजे देता है।

यह मॉडल इन स्थितियों में अच्छा काम करता है:

• सपोर्ट एजेंट्स: ऐसे वॉइस एजेंट्स को शक्ति दें जो ग्राहकों के सवालों को रीयलटाइम में हल करें।
• AI असिस्टेंट्स: व्यापक भावनात्मक रेंज और संदर्भ की समझ के साथ स्वाभाविक, जीवंत संवाद जनरेट करें।
• इंटरैक्टिव किरदार: अभिव्यक्तिपूर्ण किरदारों वाले ऑडियो अनुभवों के लिए बेहतरीन।

Eleven v4 Turbo टेक्स्ट टू डायलॉग वेबस्कॉकेट के ज़रिए उपलब्ध है।

समर्थित भाषाएँ

Eleven v4 मॉडल परिवार 90+ भाषाओं को सपोर्ट करता है, जिनमें शामिल हैं:

अफ़्रीकान्स (afr), अम्हारिक (amh), अरबी (ara), आर्मेनियाई (hye), असमिया (asm), अस्तूरियाई (ast), अज़रबैजानी (aze), बेलारूसी (bel), बांग्ला (ben), बोस्नियाई (bos), बल्गेरियाई (bul), बर्मी (mya), कैंटोनीज़ (yue), कैटलन (cat), सेबुआनो (ceb), क्रोएशियाई (hrv), चेक (ces), डेनिश (dan), डच (nld), अंग्रेज़ी (eng), एस्टोनियाई (est), फ़िलिपीनो (fil), फ़िनिश (fin), फ़्रेंच (fra), फूला/पुलार (ful), गैलिशियन (glg), जॉर्जियाई (kat), जर्मन (deu), यूनानी (ell), गुजराती (guj), हौसा (hau), हिब्रू (heb), हिंदी (hin), हंगेरियाई (hun), आइसलैंडिक (isl), इंडोनेशियाई (ind), इतालवी (ita), जापानी (jpn), जावानीज़ (jav), कांबा (kam), कन्नड़ (kan), कज़ाख़ (kaz), कोरियाई (kor), किर्गिज़ (kir), लाओ (lao), लातवियाई (lav), लिंगाला (lin), लिथुआनियाई (lit), लुगांडा (lug), लक्ज़मबर्गिश (ltz), मैसिडोनियाई (mkd), मलय (msa), मलयालम (mal), माल्टीज़ (mlt), मंदारिन चीनी (cmn), माओरी (mri), मराठी (mar), मंगोलियाई (mon), नेपाली (nep), नॉर्वेजियन बोकमॉल (nob), ओक्सितान (oci), ओड़िया (ori), पश्तो (pus), फ़ारसी (fas), पोलिश (pol), पुर्तगाली, ब्राज़ील (por), पंजाबी (pan), रोमानियाई (ron), रूसी (rus), सर्बियाई (srp), शोना (sna), सिंधी (snd), स्लोवाक (slk), स्लोवेनियाई (slv), सोमाली (som), सोरानी कुर्दिश (ckb), स्पेनिश, लैटिन अमेरिका (spa), स्वाहिली (swa), स्वीडिश (swe), ताजिक (tgk), तमिल (tam), तेलुगु (tel), थाई (tha), तुर्की (tur), यूक्रेनी (ukr), उर्दू (urd), उज़्बेक (uzb), वियतनामी (vie), वेल्श (cym), वोलोफ़ (wol), ज़ुलू (zul)।

Eleven v3

Eleven v3 हमारी पिछली पीढ़ी का स्पीच सिंथेसिस मॉडल है, जो कई भाषाओं में व्यापक भावनात्मक रेंज और संदर्भ की समझ के साथ स्वाभाविक, जीवंत स्पीच तैयार करता है।

Eleven v3 के साथ नया टेक्स्ट टू डायलॉग API आता है, जिससे आप कई भाषाओं में व्यापक भावनात्मक रेंज और संदर्भ की समझ के साथ स्वाभाविक, जीवंत संवाद जनरेट कर सकते हैं। Eleven v3 का इस्तेमाल टेक्स्ट टू स्पीच API के साथ भी किया जा सकता है, ताकि कई भाषाओं में व्यापक भावनात्मक रेंज और संदर्भ की समझ के साथ स्वाभाविक, जीवंत स्पीच जनरेट की जा सके।

टेक्स्ट टू डायलॉग API के बारे में यहाँ और पढ़ें।

समर्थित भाषाएँ

Eleven v3 मॉडल 70+ भाषाओं को support करता है, जिनमें शामिल हैं:

अफ़्रीकान्स (afr), अरबी (ara), अर्मेनियाई (hye), असमिया (asm), अज़रबैजानी (aze), बेलारूसी (bel), बांग्ला (ben), बोस्नियाई (bos), बल्गेरियाई (bul), कैटलन (cat), सेबुआनो (ceb), चिचेवा (nya), क्रोएशियाई (hrv), चेक (ces), डेनिश (dan), डच (nld), अंग्रेज़ी (eng), एस्टोनियाई (est), फ़िलिपीनो (fil), फ़िनिश (fin), फ़्रेंच (fra), गैलिशियन (glg), जॉर्जियाई (kat), जर्मन (deu), यूनानी (ell), गुजराती (guj), हौसा (hau), हिब्रू (heb), हिंदी (hin), हंगेरियन (hun), आइसलैंडिक (isl), इंडोनेशियाई (ind), आयरिश (gle), इतालवी (ita), जापानी (jpn), जावानीज़ (jav), कन्नड़ (kan), कज़ाख़ (kaz), किर्गिज़ (kir), कोरियाई (kor), लातवियाई (lav), लिंगाला (lin), लिथुआनियाई (lit), लक्ज़मबर्गिश (ltz), मैसेडोनियाई (mkd), मलय (msa), मलयालम (mal), मंदारिन चीनी (cmn), मराठी (mar), नेपाली (nep), नॉर्वेजियन (nor), पश्तो (pus), फ़ारसी (fas), पोलिश (pol), पुर्तगाली (por), पंजाबी (pan), रोमानियाई (ron), रूसी (rus), सर्बियाई (srp), सिंधी (snd), स्लोवाक (slk), स्लोवेनियाई (slv), सोमाली (som), स्पेनिश (spa), स्वाहिली (swa), स्वीडिश (swe), तमिल (tam), तेलुगु (tel), थाई (tha), तुर्की (tur), यूक्रेनी (ukr), उर्दू (urd), वियतनामी (vie), वेल्श (cym)।

Eleven v3 Conversational

Eleven v3 Conversational रीयलटाइम स्पीच सिंथेसिस के लिए हमारी पिछली पीढ़ी का मॉडल है। यह कई भाषाओं में व्यापक भावनात्मक रेंज और संदर्भ की समझ के साथ स्वाभाविक, जीवंत स्पीच तैयार करता है।

Eleven v3 Conversational के साथ नया टेक्स्ट टू डायलॉग WebSocket आता है, जिससे आप कई भाषाओं में व्यापक भावनात्मक रेंज और संदर्भ की समझ के साथ स्वाभाविक, जीवंत संवाद जनरेट कर सकते हैं।

Eleven v3 Conversational के साथ नया टेक्स्ट टू डायलॉग WebSocket आता है, जिससे आप कई भाषाओं में व्यापक भावनात्मक रेंज और संदर्भ की समझ के साथ स्वाभाविक, जीवंत संवाद जनरेट कर सकते हैं।

टेक्स्ट टू डायलॉग WebSocket के बारे में यहाँ और पढ़ें।

समर्थित भाषाएँ

Eleven v3 मॉडल 70+ भाषाओं को support करता है, जिनमें शामिल हैं:

अफ़्रीकान्स (afr), अरबी (ara), अर्मेनियाई (hye), असमिया (asm), अज़रबैजानी (aze), बेलारूसी (bel), बांग्ला (ben), बोस्नियाई (bos), बल्गेरियाई (bul), कैटलन (cat), सेबुआनो (ceb), चिचेवा (nya), क्रोएशियाई (hrv), चेक (ces), डेनिश (dan), डच (nld), अंग्रेज़ी (eng), एस्टोनियाई (est), फ़िलिपीनो (fil), फ़िनिश (fin), फ़्रेंच (fra), गैलिशियन (glg), जॉर्जियाई (kat), जर्मन (deu), यूनानी (ell), गुजराती (guj), हौसा (hau), हिब्रू (heb), हिंदी (hin), हंगेरियन (hun), आइसलैंडिक (isl), इंडोनेशियाई (ind), आयरिश (gle), इतालवी (ita), जापानी (jpn), जावानीज़ (jav), कन्नड़ (kan), कज़ाख़ (kaz), किर्गिज़ (kir), कोरियाई (kor), लातवियाई (lav), लिंगाला (lin), लिथुआनियाई (lit), लक्ज़मबर्गिश (ltz), मैसेडोनियाई (mkd), मलय (msa), मलयालम (mal), मंदारिन चीनी (cmn), मराठी (mar), नेपाली (nep), नॉर्वेजियन (nor), पश्तो (pus), फ़ारसी (fas), पोलिश (pol), पुर्तगाली (por), पंजाबी (pan), रोमानियाई (ron), रूसी (rus), सर्बियाई (srp), सिंधी (snd), स्लोवाक (slk), स्लोवेनियाई (slv), सोमाली (som), स्पेनिश (spa), स्वाहिली (swa), स्वीडिश (swe), तमिल (tam), तेलुगु (tel), थाई (tha), तुर्की (tur), यूक्रेनी (ukr), उर्दू (urd), वियतनामी (vie), वेल्श (cym)।

Multilingual v2

Eleven Multilingual v2 हमारी पिछली पीढ़ी का भावनात्मक समझ वाला स्पीच सिंथेसिस मॉडल है। यह कई भाषाओं में व्यापक भावनात्मक रेंज और संदर्भ की समझ के साथ स्वाभाविक, जीवंत स्पीच तैयार करता है।

यह मॉडल सभी समर्थित भाषाओं में वॉइस की एक जैसी क्वालिटी और व्यक्तित्व बनाए रखता है, साथ ही स्पीकर की विशिष्ट विशेषताओं और लहजे को भी बरकरार रखता है।

यह मॉडल उन स्थितियों में बेहतरीन है, जहाँ उच्च क्वालिटी की भावनात्मक रूप से सूक्ष्म स्पीच चाहिए:

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

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

हमारे multilingual v2 मॉडल्स 29 भाषाओं को support करते हैं:

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

Flash v2.5

Eleven Flash v2.5 हमारा सबसे तेज़ स्पीच सिंथेसिस मॉडल है, जिसे रीयल-टाइम ऐप्लिकेशन और Agents Platform के लिए डिज़ाइन किया गया है। यह 32 भाषाओं में बेहद कम लेटेंसी (~75ms†) के साथ उच्च-क्वालिटी स्पीच देता है।

यह मॉडल गति और क्वालिटी के बीच संतुलन बनाता है, इसलिए इंटरैक्टिव ऐप्लिकेशन के लिए आदर्श है। साथ ही, यह स्वाभाविक आउटपुट और भाषाओं के बीच वॉइस की एक जैसी विशेषताएँ बनाए रखता है।

यह मॉडल खास तौर पर इनके लिए उपयुक्त है:

• Agents Platform: रीयल-टाइम वॉइस एजेंट्स और चैटबॉट्स के लिए एकदम सही।
• इंटरैक्टिव ऐप्लिकेशन: ऐसे गेम्स और ऐप्लिकेशन के लिए आदर्श जिन्हें तुरंत जवाब चाहिए।
• बड़े स्तर पर प्रोसेसिंग: बड़े पैमाने पर टेक्स्ट-टू-स्पीच कन्वर्ज़न के लिए कुशल।

API जनरेशन के लिए इसकी कम कीमत और 75ms लेटेंसी के कारण, Flash v2.5 कई भाषाओं में तेज़ और भरोसेमंद स्पीच सिंथेसिस चाहने वाले हर व्यक्ति के लिए किफ़ायती विकल्प है।

Flash v2.5, v2 मॉडल्स की सभी भाषाओं के साथ-साथ 32 भाषाओं को support करता है:

हंगेरियन, नॉर्वेजियन और वियतनामी

ध्यान देने योग्य बातें

मॉडल चुनने की गाइड

आपकी ज़रूरतों और उपयोग के मामले के लिए कौन-सा मॉडल सबसे सही है, यह जानने के लिए मॉडल चुनने की गाइड देखें।

कैरेक्टर सीमाएं

एक टेक्स्ट-टू-स्पीच रिक्वेस्ट में समर्थित कैरेक्टर की अधिकतम संख्या मॉडल के अनुसार अलग-अलग होती है।

Scribe v2

Scribe v2 हमारा अत्याधुनिक स्पीच रिकग्निशन मॉडल है, जिसे 90+ भाषाओं में सटीक ट्रांसक्रिप्शन के लिए डिज़ाइन किया गया है। यह शब्द-स्तर के सटीक टाइमस्टैम्प और स्पीकर डायराइज़ेशन व डायनामिक ऑडियो टैगिंग जैसी उन्नत सुविधाएं देता है।

यह मॉडल उन स्थितियों में बेहतरीन है जहां सटीक स्पीच-टू-टेक्स्ट कन्वर्ज़न की ज़रूरत होती है:

• ट्रांसक्रिप्शन सेवाएं: ऑडियो/वीडियो कंटेंट को टेक्स्ट में बदलने के लिए बेहतरीन
• मीटिंग डॉक्यूमेंटेशन: बातचीत को कैप्चर और डॉक्यूमेंट करने के लिए आदर्श
• कंटेंट विश्लेषण: ऑडियो कंटेंट की प्रोसेसिंग और विश्लेषण के लिए उपयुक्त
• बहुभाषी पहचान: 90+ भाषाओं में सटीक ट्रांसक्रिप्शन का समर्थन

मुख्य सुविधाएं:

• शब्द-स्तर के टाइमस्टैम्प के साथ सटीक ट्रांसक्रिप्शन
• कई स्पीकर वाले ऑडियो के लिए स्पीकर डायराइज़ेशन
• बेहतर संदर्भ के लिए डायनामिक ऑडियो टैगिंग
• 90+ भाषाओं का समर्थन
• एंटिटी डिटेक्शन
• कीटर्म प्रॉम्प्टिंग
• ट्रांसक्रिप्ट एडिटिंग

Scribe v2 के बारे में ज़्यादा यहां पढ़ें।

Scribe v2 Realtime

Scribe v2 Realtime, हमारा सबसे तेज़ और सबसे सटीक लाइव स्पीच रिकग्निशन मॉडल, बेहद कम 150ms लेटेंसी के साथ 90 से ज़्यादा भाषाओं में अत्याधुनिक सटीकता देता है।

यह मॉडल बातचीत वाले उपयोग के मामलों में बेहतरीन है:

• लाइव मीटिंग ट्रांसक्रिप्शन: रीयल-टाइम ट्रांसक्रिप्शन के लिए बेहतरीन
• AI एजेंट्स: लाइव बातचीत के लिए आदर्श
• बहुभाषी पहचान: ऑटोमैटिक भाषा पहचान के साथ 90+ भाषाओं में सटीक ट्रांसक्रिप्शन का समर्थन

मुख्य सुविधाएं:

• बेहद कम लेटेंसी: ~150 मिलीसेकंड में आंशिक ट्रांसक्रिप्शन पाएं
• स्ट्रीमिंग समर्थन: रीयल-टाइम में ट्रांसक्रिप्ट पाते हुए ऑडियो को हिस्सों में भेजें
• कई ऑडियो फ़ॉर्मैट: PCM (8kHz से 48kHz) और μ-law एन्कोडिंग का समर्थन
• वॉइस एक्टिविटी डिटेक्शन (VAD): साइलेंस डिटेक्शन के आधार पर ऑटोमैटिक स्पीच सेगमेंटेशन
• मैनुअल कमिट कंट्रोल: ट्रांसक्रिप्ट सेगमेंट को कब फ़ाइनल करना है, इस पर पूरा नियंत्रण
• एंटिटी डिटेक्शन
• ट्रांसक्रिप्ट एडिटिंग

Scribe v2 Realtime के बारे में ज़्यादा यहां पढ़ें।

Scribe v2 Medical

Scribe v2 Medical मेडिकल और क्लिनिकल ऑडियो के लिए विशेष रूप से बनाया गया बैच स्पीच रिकग्निशन मॉडल है। यह Scribe v2 का एक फाइनट्यून है, जो रोज़मर्रा की बातचीत में Scribe v2 की सटीकता बनाए रखते हुए दवाओं के नाम, शरीर रचना, पैथोलॉजी और क्लिनिकल डिक्टेशन की पहचान बेहतर करता है। यह Scribe v2 के समान स्पीच टू टेक्स्ट API इस्तेमाल करता है और इसकी कीमत भी समान है। model_id के रूप में scribe_v2_medical भेजें।

यह मॉडल इनके लिए उपयुक्त है:

• क्लिनिकल डॉक्यूमेंटेशन: बातचीत के दौरान मेडिकल शब्द आने वाले एम्बिएंट एनकाउंटर और नोट्स
• डिक्टेशन: दवाओं, डोज़ और निष्कर्षों के घने क्रम
• इंटेक और कोऑर्डिनेशन कॉल: मरीज़ अपनी स्थितियों का वर्णन करते हैं, अक्सर फ़ोन पर
• कंप्लायंस वर्कफ़्लो: PHI कैटेगरी के लिए एंटिटी डिटेक्शन के साथ इस्तेमाल करें

मुख्य सुविधाएं:

• Scribe v2 जैसा ही रिक्वेस्ट फ़ॉर्मैट (keyterms, entity_detection, no_verbatim, डायराइज़ेशन, टाइमस्टैम्प)
• दवाओं के नाम, शरीर रचना और पैथोलॉजी शब्दों की बेहतर पहचान
• Scribe v2 की तुलना में रोज़मर्रा की बातचीत पर कोई सटीकता कमी नहीं
• 90+ भाषाओं का समर्थन
• कई स्पीकर वाले ऑडियो के लिए स्पीकर डायराइज़ेशन
• डायनामिक ऑडियो टैगिंग
• PHI कैटेगरी समेत एंटिटी डिटेक्शन

Scribe v2 Medical एक बैच मॉडल है। लाइव ट्रांसक्रिप्शन के लिए Scribe v2 Realtime इस्तेमाल करें।

Scribe v2 Medical HIPAA के लिए योग्य है। Enterprise ग्राहकों के लिए बिज़नेस एसोसिएट एग्रीमेंट और ज़ीरो रिटेंशन मोड (ZRM) उपलब्ध हैं। ZRM सक्षम होने पर, हर रिक्वेस्ट पूरी होते ही ऑडियो इनपुट और टेक्स्ट आउटपुट हटा दिए जाते हैं। ElevenLabs कुछ भी रिटेन नहीं करता और आपका ऐप्लिकेशन पूरा API रिस्पॉन्स पाता है तथा आपके अपने नियंत्रणों के तहत ट्रांसक्रिप्ट रिटेन करता है।

स्पीच टू टेक्स्ट के बारे में ज़्यादा यहां पढ़ें।

Eleven Music

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

यह मॉडल इन स्थितियों के लिए बेहतरीन है:

• गेम साउंडट्रैक: गेम्स के लिए इमर्सिव साउंडट्रैक बनाएं
• पॉडकास्ट बैकग्राउंड: प्रोफेशनल संगीत से पॉडकास्ट को बेहतर बनाएं
• मार्केटिंग: ऐड रील्स में बैकग्राउंड म्यूज़िक जोड़ें

मुख्य सुविधाएं:

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

Eleven Music के बारे में ज़्यादा यहां पढ़ें।

समवर्ती अनुरोध और प्राथमिकता

आपकी सब्सक्रिप्शन योजना तय करती है कि कितने अनुरोध एक साथ प्रोसेस किए जा सकते हैं और क्यू में आपके अनुरोधों की प्राथमिकता क्या होगी। स्पीच टू टेक्स्ट की समवर्ती अनुरोध सीमा अधिक है। समवर्ती अनुरोध सीमा पूरी होने पर, बाद के अनुरोध कम-प्राथमिकता वाले अनुरोधों के साथ क्यू में प्रोसेस किए जाते हैं। व्यवहार में, इससे आमतौर पर केवल ~50ms की लेटेंसी जुड़ती है।

रिस्पॉन्स हेडर में current-concurrent-requests और maximum-concurrent-requests शामिल होते हैं, जिनका इस्तेमाल करके आप अपने समवर्ती अनुरोधों को मॉनिटर कर सकते हैं।

प्रति मिनट API अनुरोध बनाम समवर्ती अनुरोध

यह समझना ज़रूरी है कि प्रति मिनट API अनुरोध और समवर्ती अनुरोध अलग-अलग मेट्रिक हैं, जो आपके इस्तेमाल के पैटर्न पर निर्भर करते हैं।

प्रति मिनट API अनुरोध समवर्ती अनुरोधों से अलग हो सकते हैं, क्योंकि यह हर अनुरोध में लगने वाले समय और अनुरोधों को बैच करने के तरीके पर निर्भर करता है।

उदाहरण 1: अंतराल वाले अनुरोध अगर आपके पास प्रति मिनट 180 अनुरोध हों, जिनमें से हर एक को पूरा होने में 1 सेकंड लगता हो और आप उन्हें 0.33 सेकंड के अंतराल पर भेजें, तो अधिकतम समवर्ती अनुरोध 3 और औसत भी 3 होगा, क्योंकि हमेशा 3 अनुरोध प्रगति पर होंगे।

उदाहरण 2: बैच किए गए अनुरोध वहीं, अगर आपका इस्तेमाल पैटर्न अलग हो, जैसे प्रति मिनट 180 अनुरोध, जिनमें से हर एक को पूरा होने में 3 सेकंड लगते हों, लेकिन सभी एक साथ भेजे जाएं, तो अधिकतम समवर्ती अनुरोध 180 और औसत 9 होगा (मिनट के पहले 3 सेकंड में एक साथ 180 अनुरोध आएंगे, अंतिम 57 सेकंड में 0 अनुरोध आएंगे)।

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

एंडपॉइंट अनुरोध करने का तरीका समवर्ती अनुरोध सीमाओं को प्रभावित करता है:

• HTTP में, हर अनुरोध आपकी समवर्ती अनुरोध सीमा में अलग-अलग गिना जाता है।
• टेक्स्ट टू स्पीच WebSocket में, केवल वह समय आपकी समवर्ती अनुरोध सीमा में गिना जाता है जब हमारा मॉडल ऑडियो जनरेट कर रहा होता है। यानी, ज़्यादातर समय खुला websocket आपकी समवर्ती अनुरोध सीमा में बिल्कुल नहीं गिना जाता।
• टेक्स्ट टू डायलॉग WebSockets अलग तरह से काम करते हैं: हर खुला कनेक्शन, खुले रहने तक एक अलग पूल से एक डायलॉग सेशन आरक्षित रखता है और कनेक्शन पर जनरेट किया गया ऑडियो आपकी मानक समवर्ती अनुरोध सीमा में नहीं गिना जाता। इसे समझना आसान बनाने के लिए डिज़ाइन किया गया है: एक कनेक्शन एक सेशन होता है और आपकी डायलॉग सेशन सीमाएं इस नई समवर्ती अनुरोध पद्धति के अनुसार तय की गई हैं। टेक्स्ट टू डायलॉग समवर्ती अनुरोध देखें।

समवर्ती अनुरोध सीमाओं को समझना

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

सामान्य तौर पर, 5 की समवर्ती अनुरोध सीमा आमतौर पर लगभग 100 एक साथ ऑडियो ब्रॉडकास्ट को सपोर्ट कर सकती है।

ऐसा इसलिए है क्योंकि ऑडियो जनरेट होने की गति, TTS अनुरोध प्रोसेस होने में लगने वाले समय की तुलना में अलग होती है। नीचे दिया गया डायग्राम दिखाता है कि अलग-अलग यूज़र्स के साथ 4 समवर्ती कॉल कैसे केवल 2 समवर्ती अनुरोधों के साथ की जा सकती हैं।

अगर किसी भी समय आप अपनी योजना की समवर्ती अनुरोध सीमाओं से अधिक जाते हैं और आप Enterprise योजना पर हैं, तो उपलब्ध क्षमता के आधार पर मॉडल अनुरोध धीमे होने के बावजूद सर्वोत्तम प्रयास के आधार पर सफल हो सकते हैं।

टेक्स्ट टू डायलॉग समवर्ती अनुरोध

टेक्स्ट टू डायलॉग अनुरोधों का मीटरिंग API को कॉल करने के तरीके के आधार पर दो अलग-अलग तरीकों से होता है:

• HTTP एंडपॉइंट (डायलॉग बनाएं और डायलॉग स्ट्रीम करें) ऑडियो जनरेट होते समय आपकी योजना की मानक समवर्ती अनुरोध सीमा में गिने जाते हैं, किसी भी अन्य टेक्स्ट टू स्पीच अनुरोध की तरह।
• टेक्स्ट टू डायलॉग WebSocket जैसे WebSocket एंडपॉइंट को डायलॉग सेशन के रूप में मीटर किया जाता है। खुला कनेक्शन, खुले रहने तक एक डायलॉग सेशन रखता है, चाहे उस समय ऑडियो जनरेट हो रहा हो या नहीं।

सेशन-आधारित मीटरिंग क्षमता की योजना को सरल रखती है: एक कनेक्शन एक सेशन है, इसलिए आपका उपयोग जनरेशन गतिविधि के साथ बदलता नहीं है। चूंकि सेशन केवल ऑडियो जनरेट होने के दौरान नहीं, बल्कि पूरे कनेक्शन के लिए रखा जाता है, इसलिए आपकी डायलॉग सेशन सीमाएं इस नई समवर्ती अनुरोध पद्धति के अनुसार तय की गई हैं।

अगर आप उस समय कनेक्शन खोलते हैं जब आपके workspace के सभी डायलॉग सेशन इस्तेमाल में हैं, तो नया कनेक्शन too_many_concurrent_requests त्रुटि के साथ अस्वीकार कर दिया जाता है। सेशन खाली करने के लिए, जिन कनेक्शनों की अब ज़रूरत नहीं है उन्हें बंद कर दें — अगर आप keep_alive संदेश नहीं भेजते हैं, तो निष्क्रियता के 20 सेकंड बाद कनेक्शन अपने-आप भी बंद हो जाता है।

डायलॉग सेशन मॉनिटर करने के लिए, डैशबोर्ड साइडबार के नीचे Developers खोलें, Analytics टैब चुनें और Usage व्यू में Concurrent requests मेट्रिक देखें। डायलॉग सेशन को आपके अन्य समवर्ती अनुरोधों से अलग, उनकी अपनी सीरीज़ TTD Websocket Sessions के रूप में रिपोर्ट किया जाता है।

समवर्ती अनुरोध सीमाओं का स्केल परीक्षण

क्लाइंट-साइड स्केलिंग समस्याओं की पहचान करने और यह जांचने के लिए कि आपके उपयोग के मामले के लिए समवर्ती अनुरोध सीमाएं सही ढंग से सेट हैं, स्केल परीक्षण उपयोगी हो सकता है।

वास्तविक इस्तेमाल के जितना संभव हो उतना करीब, एंड-टू-एंड वर्कफ़्लो का परीक्षण करने की पुरज़ोर सलाह दी जाती है। इसके लिए कितने यूज़र्स को सपोर्ट किया जा सकता है, इसे सिम्युलेट करना और मापना सुझाई गई पद्धति है। यह ज़रूरी है कि आप:

• रॉ अनुरोधों का नहीं, यूज़र्स का सिमुलेशन करें
• सामान्य यूज़र व्यवहार का सिमुलेशन करें, जैसे अनुरोध करने से पहले ऑडियो प्लेबैक, यूज़र के बोलने या ट्रांसक्रिप्शन पूरा होने का इंतज़ार करना
• कुछ मिनटों की अवधि में यूज़र्स की संख्या धीरे-धीरे बढ़ाएं
• अनुरोधों के समय और आकार में रैंडमनेस जोड़ें
• API से मिलने वाले लेटेंसी मेट्रिक और सभी त्रुटि कोड कैप्चर करें

उदाहरण के लिए, 100 एक साथ बातचीत को सपोर्ट करने के लिए डिज़ाइन किए गए एजेंट सिस्टम का परीक्षण करने हेतु, आप अधिकतम 100 अलग-अलग “यूज़र” बनाएंगे, जिनमें से हर एक बातचीत का सिमुलेशन करेगा। बातचीत में आमतौर पर ~10 सेकंड यूज़र के बोलने का दोहराया जाने वाला चक्र होता है, उसके बाद ~150 कैरेक्टर के लिए TTS API कॉल और फिर यूज़र को ~10 सेकंड ऑडियो प्लेबैक होता है। इसलिए, हर यूज़र को हर 20 सेकंड में 150 कैरेक्टर के टेक्स्ट के लिए एक websocket टेक्स्ट-टू-स्पीच API कॉल करने के पैटर्न का पालन करना चाहिए, जिसमें प्रतीक्षा अवधि और अनुरोधित कैरेक्टरों की संख्या में थोड़ा रैंडमनेस शामिल हो। परीक्षण में हर सेकंड एक यूज़र शुरू करना शामिल होगा, जब तक कि 100 यूज़र न हो जाएं, और फिर समग्र स्थिरता जांचने के लिए कुल 10 मिनट तक परीक्षण करना होगा।

import json
import random
import time
import gevent
import locust
from locust import User, task, events, constant_throughput
import websocket
# Averages up to 10 seconds of audio when played, depends on the voice speed
DEFAULT_TEXT = (
    "Hello, this is a test message. I am testing if a long input will cause issues for the model "
    "like this sentence. "
)
TEXT_ARRAY = [
    "Hello.",
    "Hello, this is a test message.",
    DEFAULT_TEXT,
    DEFAULT_TEXT * 2,
    DEFAULT_TEXT * 3
]
# Custom command line arguments
@events.init_command_line_parser.add_listener
def on_parser_init(parser):
    parser.add_argument("--api-key", default="YOUR_API_KEY", help="API key for authentication")
    parser.add_argument("--encoding", default="mp3_22050_32", help="Encoding")
    parser.add_argument("--text", default=DEFAULT_TEXT, help="Text to use")
    parser.add_argument("--use-text-array", default="false", help="Text to use")
    parser.add_argument("--voice-id", default="aria", help="Text to use")
class WebSocketTTSUser(User):
    # Each user will send a request every 20 seconds, regardless of how long each request takes
    wait_time = constant_throughput(0.05)
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.api_key = self.environment.parsed_options.api_key
        self.voice_id = self.environment.parsed_options.voice_id
        self.text = self.environment.parsed_options.text
        self.encoding = self.environment.parsed_options.encoding
        self.use_text_array = self.environment.parsed_options.use_text_array
        if self.use_text_array:
            self.text = random.choice(TEXT_ARRAY)
        self.all_recieved = False
    @task
    def tts_task(self):
        # Do jitter waiting of up to 1 second
        # Users appear to be spawned every second so this ensures requests are not aligned
        gevent.sleep(random.random())
        max_wait_time = 10
        # Connection details
        uri = f"{self.environment.host}/v1/text-to-speech/{self.voice_id}/stream-input?auto_mode=true&output_format={self.encoding}"
        headers = {"xi-api-key": self.api_key}
        ws = None
        self.all_recieved = False
        try:
            init_msg = {"text": " "}
            # Use proper header format for websocket - this is case sensitive!
            ws = websocket.create_connection(uri, header=headers)
            ws.send(json.dumps(init_msg))
            # Start measuring after websocket initiated but before any messages are sent
            send_request_time = time.perf_counter()
            ws.send(json.dumps({"text": self.text}))
            # Send to flush and receive the audio
            ws.send(json.dumps({"text": ""}))
            def _receive():
                t_first_response = None
                audio_size = 0
                try:
                    while True:
                        # Wait up to 10 seconds for a response
                        ws.settimeout(max_wait_time)
                        response = ws.recv()
                        response_data = json.loads(response)
                        if "audio" in response_data and response_data["audio"]:
                            audio_size = audio_size + len(response_data["audio"])
                        if t_first_response is None:
                            t_first_response = time.perf_counter()
                            first_byte_ms = (
                                t_first_response - send_request_time
                            ) * 1000
                            if audio_size is None:
                                # The first response should always have audio
                                locust.events.request.fire(
                                    request_type="websocket",
                                    name="Bad Response (no audio)",
                                    response_time=first_byte_ms,
                                    response_length=audio_size,
                                    exception=Exception("Response has no audio"),
                                )
                                break
                        if "isFinal" in response_data and response_data["isFinal"]:
                            # Fire this event once finished streaming, but report the important TTFB metric
                            locust.events.request.fire(
                                request_type="websocket",
                                name="TTS Stream Success (First Byte)",
                                response_time=first_byte_ms,
                                response_length=audio_size,
                                exception=None,
                            )
                            break
                except websocket.WebSocketTimeoutException:
                    locust.events.request.fire(
                        request_type="websocket",
                        name="TTS Stream Timeout",
                        response_time=max_wait_time * 1000,
                        response_length=audio_size,
                        exception=Exception("Timeout waiting for response"),
                    )
                except Exception as e:
                    # Typically JSON decode error if the server returns HTTP backoff error
                    locust.events.request.fire(
                        request_type="websocket",
                        name="TTS Stream Failure",
                        response_time=0,
                        response_length=0,
                        exception=e,
                    )
                finally:
                    self.all_recieved = True
            gevent.spawn(_receive)
            # Sleep until recieved so new tasks aren't spawned
            while not self.all_recieved:
                gevent.sleep(1)
        except websocket.WebSocketTimeoutException:
            locust.events.request.fire(
                request_type="websocket",
                name="TTS Stream Timeout",
                response_time=max_wait_time * 1000,
                response_length=0,
                exception=Exception("Timeout waiting for response"),
            )
        except Exception as e:
            locust.events.request.fire(
                request_type="websocket",
                name="TTS Stream Failure",
                response_time=0,
                response_length=0,
                exception=e,
            )
        finally:
            # Try and close the websocket gracefully
            try:
                if ws:
                    ws.close()
            except Exception:
                pass