नेविगेशन पर जाएँ

मल्टीचैनल स्पीच-टू-टेक्स्ट

यह गाइड दिखाती है कि स्पीच टू टेक्स्ट API के साथ मल्टीचैनल ट्रांसक्रिप्शन मोड का इस्तेमाल कैसे करें।

कैसे करें गाइड · मानता है कि आपने स्पीच टू टेक्स्ट क्विकस्टार्ट पूरा कर लिया है।

परिचय

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

हर चैनल को स्वतंत्र रूप से प्रोसेस किया जाता है और उसके चैनल नंबर के आधार पर उसे अपने-आप एक स्पीकर ID दी जाती है (चैनल 0 → speaker_0, चैनल 1 → speaker_1, आदि)। सिस्टम आपकी इनपुट ऑडियो फ़ाइल से अलग-अलग चैनल निकालता है और उन्हें समानांतर रूप से ट्रांसक्राइब करता है। डिफ़ॉल्ट रूप से API हर चैनल के लिए एक ट्रांसक्रिप्ट लौटाता है; इसके बजाय सभी चैनलों को शुरू होने के समय के अनुसार क्रमबद्ध एक सूची में मर्ज किए गए एकल ट्रांसक्रिप्ट के रूप में पाने के लिए multichannel_output_style=combined सेट करें, जिसमें हर शब्द को उसके channel_index के साथ टैग किया जाता है।

सामान्य उपयोग के मामले

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

आवश्यकताएं

  • API key वाला ElevenLabs अकाउंट
  • मल्टीचैनल ऑडियो फ़ाइल (WAV, MP3 या अन्य समर्थित फ़ॉर्मैट)
  • हर ऑडियो फ़ाइल में अधिकतम 5 चैनल
  • हर चैनल में केवल एक स्पीकर होना चाहिए

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

1

अपना मल्टीचैनल ऑडियो तैयार करें

पक्का करें कि आपकी ऑडियो फ़ाइल में स्पीकर अलग-अलग चैनलों पर अलग किए गए हैं। मल्टीचैनल सुविधा अधिकतम 5 चैनल सपोर्ट करती है, जिसमें हर चैनल एक खास स्पीकर से मैप होता है:

  • चैनल 0 → speaker_0
  • चैनल 1 → speaker_1
  • चैनल 2 → speaker_2
  • चैनल 3 → speaker_3
  • चैनल 4 → speaker_4
2

API पैरामीटर कॉन्फ़िगर करें

स्पीच-टू-टेक्स्ट अनुरोध करते समय, आपको ये सेट करने होंगे:

  • use_multi_channel: true
  • diarize: false (मल्टीचैनल मोड चैनलों के ज़रिए स्पीकर को अलग करता है)

वैकल्पिक रूप से, प्रतिक्रिया का स्वरूप इनसे नियंत्रित करें:

  • multichannel_output_style: separate (डिफ़ॉल्ट) हर चैनल के लिए एक ट्रांसक्रिप्ट लौटाता है। combined सभी चैनलों को एक ऐसे एकल ट्रांसक्रिप्ट में मर्ज करता है जिसके शब्द शुरू होने के समय के अनुसार क्रमबद्ध होते हैं और हर शब्द में channel_index होता है — यह मानक सिंगल-चैनल प्रतिक्रिया स्वरूप से मेल खाता है। combined के लिए टाइमस्टैंप आवश्यक हैं (timestamps_granularity none नहीं होना चाहिए) और यह वेबहुक डिलीवरी या एंटिटी डिटेक्शन/रिडैक्शन के साथ समर्थित नहीं है।

num_speakers पैरामीटर का इस्तेमाल मल्टीचैनल मोड के साथ नहीं किया जा सकता, क्योंकि स्पीकर की संख्या चैनलों की संख्या से अपने-आप तय होती है। मल्टीचैनल मोड मानता है कि हर चैनल में ठीक एक स्पीकर होगा। यदि अधिक स्पीकर हैं, तो यह चैनल के सभी स्पीकर को एक ही स्पीकर ID देगा।

3

प्रतिक्रिया प्रोसेस करें

डिफ़ॉल्ट रूप से (multichannel_output_style=separate), मल्टीचैनल ऑडियो सिंगल-चैनल से अलग प्रतिक्रिया स्वरूप लौटाता है:

अगर आप use_multi_channel: true सेट करते हैं लेकिन सिंगल-चैनल (मोनो) ऑडियो फ़ाइल देते हैं, तो आपको मल्टीचैनल स्वरूप के बजाय मानक सिंगल-चैनल प्रतिक्रिया मिलेगी। मल्टीचैनल प्रतिक्रिया स्वरूप केवल तभी लौटाया जाता है, जब ऑडियो फ़ाइल में वास्तव में कई चैनल हों।

{
"language_code": "en",
"language_probability": 0.98,
"text": "Hello world",
"words": [...]
}

multichannel_output_style=combined के साथ, प्रतिक्रिया सिंगल-चैनल ट्रांसक्रिप्शन जैसा ही सपाट स्वरूप इस्तेमाल करती है (शीर्ष स्तर पर text और words, कोई transcripts ऐरे नहीं), जिसमें सभी चैनल शुरू होने के समय के अनुसार क्रमबद्ध एक सूची में मर्ज किए जाते हैं। हर शब्द में उसके चैनल की पहचान करने वाला channel_index (और speaker_id) शामिल होता है।

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

बुनियादी मल्टीचैनल ट्रांसक्रिप्शन

यहां दो स्पीकर वाली स्टीरियो ऑडियो फ़ाइल को ट्रांसक्राइब करने का पूरा उदाहरण है:

from elevenlabs import ElevenLabs
elevenlabs = ElevenLabs(api_key="YOUR_API_KEY")
def transcribe_multichannel(audio_file_path):
with open(audio_file_path, 'rb') as audio_file:
result = elevenlabs.speech_to_text.convert(
file=audio_file,
model_id='scribe_v3',
use_multi_channel=True,
diarize=False,
timestamps_granularity='word'
)
return result
# Process the response
result = transcribe_multichannel('stereo_interview.wav')
if hasattr(result, 'transcripts'): # Multichannel response
for transcript in result.transcripts:
channel = transcript.channel_index
text = transcript.text
print(f"Channel {channel} (speaker_{channel}): {text}")
else: # Single channel response (fallback)
print(f"Text: {result.text}")

बातचीत के ट्रांसक्रिप्ट बनाना

समय के अनुसार क्रमबद्ध, बातचीत-शैली का ट्रांसक्रिप्ट पाने का सबसे आसान तरीका multichannel_output_style=combined का अनुरोध करना है — API एक ही words सूची लौटाता है, जो पहले से शुरू होने के समय के अनुसार क्रमबद्ध होती है और हर शब्द में channel_index और speaker_id होता है:

संयुक्त आउटपुट (अनुशंसित)
with open("stereo_interview.wav", "rb") as audio_file:
result = elevenlabs.speech_to_text.convert(
file=audio_file,
model_id="scribe_v3",
use_multi_channel=True,
multichannel_output_style="combined",
diarize=False,
timestamps_granularity="word",
)
for word in result.words:
if word.type == "word":
print(f"speaker_{word.channel_index}: {word.text}")

अगर आप डिफ़ॉल्ट separate आउटपुट इस्तेमाल कर रहे हैं, तो आप क्लाइंट-साइड पर प्रति-चैनल ट्रांसक्रिप्ट को मर्ज कर सकते हैं:

def create_conversation_transcript(multichannel_result):
"""Create a conversation-style transcript with speaker labels"""
all_words = []
if hasattr(multichannel_result, 'transcripts'):
# Collect all words from all channels
for transcript in multichannel_result.transcripts:
for word in transcript.words or []:
if word.type == 'word':
all_words.append({
'text': word.text,
'start': word.start,
'speaker_id': word.speaker_id,
'channel': transcript.channel_index
})
# Sort by timestamp
all_words.sort(key=lambda w: w['start'])
# Group consecutive words by speaker
conversation = []
current_speaker = None
current_text = []
for word in all_words:
if word['speaker_id'] != current_speaker:
if current_text:
conversation.append({
'speaker': current_speaker,
'text': ' '.join(current_text)
})
current_speaker = word['speaker_id']
current_text = [word['text']]
else:
current_text.append(word['text'])
# Add the last segment
if current_text:
conversation.append({
'speaker': current_speaker,
'text': ' '.join(current_text)
})
return conversation
# Format the output
conversation = create_conversation_transcript(result)
for turn in conversation:
print(f"{turn['speaker']}: {turn['text']}")

मल्टीचैनल के साथ वेबहुक इस्तेमाल करना

मल्टीचैनल ट्रांसक्रिप्शन एसिंक्रोनस प्रोसेसिंग के लिए वेबहुक डिलीवरी सपोर्ट करता है:

वेबहुक separate (प्रति-चैनल) स्वरूप लौटाते हैं। multichannel_output_style=combined अभी वेबहुक डिलीवरी के साथ समर्थित नहीं है — सिंक्रोनस अनुरोध इस्तेमाल करें या प्रति-चैनल वेबहुक पेलोड को क्लाइंट-साइड पर मर्ज करें।

from elevenlabs import ElevenLabs
elevenlabs = ElevenLabs(api_key="YOUR_API_KEY")
async def transcribe_multichannel_with_webhook(audio_file_path):
with open(audio_file_path, 'rb') as audio_file:
result = await elevenlabs.speech_to_text.convert_async(
file=audio_file,
model_id='scribe_v3',
use_multi_channel=True,
diarize=False,
webhook=True # Enable webhook delivery
)
print(f"Transcription started with task ID: {result.task_id}")
return result.task_id

त्रुटि प्रबंधन

सामान्य वैलिडेशन त्रुटियां

त्रुटि: मल्टीचैनल मोड डायरीकरण सपोर्ट नहीं करता और स्पीकर को उस चैनल के आधार पर असाइन करता है जिस पर वे बोलते हैं।

समाधान: मल्टीचैनल मोड इस्तेमाल करते समय हमेशा diarize=false सेट करें।

त्रुटि: use_multi_channel सक्षम होने पर num_speakers निर्दिष्ट नहीं किया जा सकता। स्पीकर की संख्या चैनलों की संख्या से अपने-आप तय होती है। समाधान: अपने अनुरोध से num_speakers पैरामीटर हटाएं।

त्रुटि: मल्टीचैनल मोड अधिकतम 5 चैनल सपोर्ट करता है, लेकिन ऑडियो फ़ाइल में X चैनल हैं।

समाधान: केवल पहले 5 चैनल प्रोसेस करें या चैनल संख्या घटाने के लिए अपने ऑडियो को पहले प्रोसेस करें।

त्रुटि: multichannel_output_style=‘combined’ के लिए टाइमस्टैंप आवश्यक हैं; timestamps_granularity को ‘word’ या ‘character’ पर सेट करें।

समाधान: संयुक्त आउटपुट शब्दों को समय के अनुसार क्रमबद्ध करता है, इसलिए timestamps_granularity को word (डिफ़ॉल्ट) या character पर सेट करें।

त्रुटि: multichannel_output_style=‘combined’ अभी वेबहुक डिलीवरी के साथ समर्थित नहीं है।

समाधान: combined के साथ सिंक्रोनस अनुरोध इस्तेमाल करें, या वेबहुक इस्तेमाल करते समय डिफ़ॉल्ट separate आउटपुट रखें और क्लाइंट-साइड पर मर्ज करें।

सर्वोत्तम तरीके

ऑडियो तैयारी

बेहतरीन परिणामों के लिए: - बेहतर प्रदर्शन के लिए 16kHz सैंपल रेट इस्तेमाल करें - प्रोसेसिंग से पहले साइलेंट या इस्तेमाल न किए गए चैनल हटाएं - पक्का करें कि हर चैनल में केवल एक स्पीकर हो - बेहतर गुणवत्ता के लिए संभव होने पर लॉसलेस फ़ॉर्मैट (WAV) इस्तेमाल करें

प्रदर्शन ऑप्टिमाइज़ेशन

चैनलों की संख्या बढ़ने पर कॉन्करेंसी लागत रैखिक रूप से बढ़ती है। 60 सेकंड की 3-चैनल फ़ाइल की कॉन्करेंसी लागत सिंगल-चैनल फ़ाइल से 3 गुना होती है।

आप नीचे दिए गए फ़ॉर्मूले से मल्टीचैनल ऑडियो के प्रोसेसिंग समय का अनुमान लगा सकते हैं:

Processing Time=(D⋅0.3)+2+(N⋅0.5)Processing\ Time = (D \cdot 0.3) + 2 + (N \cdot 0.5)

जहां:

  • DD = सेकंड में फ़ाइल की अवधि
  • NN = चैनलों की संख्या
  • 0.30.3 = प्रोसेसिंग गति कारक (रीयल-टाइम का लगभग 30%)
  • 22 = सेकंड में स्थिर ओवरहेड
  • 0.50.5 = सेकंड में प्रति-चैनल ओवरहेड

उदाहरण: 60 सेकंड की स्टीरियो फ़ाइल (2 चैनल) के लिए:

Processing Time=(60⋅0.3)+2+(2⋅0.5)=18+2+1=21 secondsProcessing\ Time = (60 \cdot 0.3) + 2 + (2 \cdot 0.5) = 18 + 2 + 1 = 21\ seconds

मेमोरी से जुड़ी बातें

बड़ी मल्टीचैनल फ़ाइलों के लिए स्ट्रीमिंग या चंकिंग पर विचार करें:

def process_large_multichannel_file(file_path, chunk_duration=300):
"""Process large files in chunks (5-minute segments)"""
from pydub import AudioSegment
from elevenlabs import ElevenLabs
import os
elevenlabs = ElevenLabs(api_key="YOUR_API_KEY")
audio = AudioSegment.from_file(file_path)
duration_ms = len(audio)
chunk_size_ms = chunk_duration * 1000
all_transcripts = []
for start_ms in range(0, duration_ms, chunk_size_ms):
end_ms = min(start_ms + chunk_size_ms, duration_ms)
# Extract chunk
chunk = audio[start_ms:end_ms]
chunk_file = f"temp_chunk_{start_ms}.wav"
chunk.export(chunk_file, format="wav")
# Transcribe chunk using SDK
with open(chunk_file, 'rb') as audio_file:
result = elevenlabs.speech_to_text.convert(
file=audio_file,
model_id='scribe_v3',
use_multi_channel=True,
diarize=False,
timestamps_granularity='word'
)
# Adjust timestamps
if hasattr(result, 'transcripts'):
for transcript in result.transcripts:
for word in transcript.words or []:
word.start += start_ms / 1000
word.end += start_ms / 1000
all_transcripts.extend(result.transcripts)
# Clean up
os.remove(chunk_file)
return all_transcripts

FAQ

API एक त्रुटि लौटाएगा। आपको या तो API को भेजने के लिए 5 चैनल चुनने होंगे या API को भेजने से पहले कुछ चैनलों को मिक्स डाउन करना होगा।

हां, लेकिन यह ज़रूरी नहीं है। अगर आप use_multi_channel=true के साथ मोनो ऑडियो भेजते हैं, तो आपको मल्टीचैनल स्वरूप के बजाय मानक सिंगल-चैनल प्रतिक्रिया मिलेगी।

हां। सभी चैनलों को मर्ज करके शुरू होने के समय के अनुसार क्रमबद्ध एकल ट्रांसक्रिप्ट पाने के लिए multichannel_output_style=combined सेट करें, जिसमें हर शब्द को उसके channel_index के साथ टैग किया जाता है। यह मानक सिंगल-चैनल प्रतिक्रिया स्वरूप से मेल खाता है। इसके लिए टाइमस्टैंप आवश्यक हैं और यह वेबहुक डिलीवरी के साथ उपलब्ध नहीं है।

स्पीकर ID चैनल नंबर के आधार पर निर्धारित होती हैं: चैनल 0 speaker_0 बनता है, चैनल 1 speaker_1 बनता है, और इसी तरह आगे।

हां, हर चैनल को स्वतंत्र रूप से प्रोसेस किया जाता है और वह अलग-अलग भाषाएं पहचान सकता है। भाषा पहचान हर चैनल पर होती है। multichannel_output_style=combined के साथ, शीर्ष-स्तरीय language_code सबसे अधिक भरोसेमंद चैनल को दर्शाता है, जबकि हर शब्द में फिर भी उसका channel_index होता है।

अगले कदम