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

परिचय

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

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

आम उपयोग के मामले

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

आवश्यकताएं

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

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

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

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

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

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

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_v2',
            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 हर शब्द पर channel_index और speaker_id के साथ, शुरू होने के समय के अनुसार पहले से क्रमबद्ध एक ही words सूची लौटाता है:

with open("stereo_interview.wav", "rb") as audio_file:
    result = elevenlabs.speech_to_text.convert(
        file=audio_file,
        model_id="scribe_v2",
        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']}")

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

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

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_v2',
            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

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

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

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

ऑडियो तैयार करना

परफ़ॉर्मेंस ऑप्टिमाइज़ेशन

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

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

जहां:

• $D$ = फ़ाइल की अवधि, सेकंड में
• $N$ = चैनलों की संख्या
• $0.3$ = प्रोसेसिंग स्पीड फ़ैक्टर (लगभग रियल-टाइम का 30%)
• $2$ = सेकंड में निश्चित ओवरहेड
• $0.5$ = सेकंड में प्रति-चैनल ओवरहेड

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

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

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

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_v2',
                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

अगले चरण