Spraak-naar-tekst met meerdere kanalen

Overzicht

Met de Speech to Text-functie voor meerdere kanalen kun je audiobestanden transcriberen waarin elk kanaal een afzonderlijke spreker bevat. Dit is vooral nuttig voor opnamen waarbij sprekers zijn geïsoleerd op afzonderlijke audiokanalen, zodat je schonere transcripties krijgt zonder sprekerdiarisatie.

Elk kanaal wordt onafhankelijk verwerkt en krijgt automatisch een spreker-ID toegewezen op basis van het kanaalnummer (kanaal 0 → speaker_0, kanaal 1 → speaker_1, enzovoort). Het systeem extraheert afzonderlijke kanalen uit je ingevoerde audiobestand en transcribeert ze parallel. Standaard retourneert de API één transcript per kanaal; stel multichannel_output_style=combined in om in plaats daarvan één transcript te ontvangen waarin alle kanalen zijn samengevoegd tot één lijst, gesorteerd op starttijd, waarbij elk woord is gelabeld met de bijbehorende channel_index.

Veelvoorkomende toepassingen

• Stereo-interviewopnamen - Interviewer op het linkerkanaal, geïnterviewde op het rechterkanaal
• Podcastopnamen met meerdere tracks - Elke deelnemer wordt op een afzonderlijke track opgenomen
• Callcenteropnamen - Agent en klant zijn gescheiden op verschillende kanalen
• Conferentieopnamen - Afzonderlijke deelnemers zijn geïsoleerd op aparte kanalen
• Rechtszittingen - Meerdere partijen worden op afzonderlijke kanalen opgenomen

Vereisten

• Een ElevenLabs-account met een API-sleutel
• Audiobestand met meerdere kanalen (WAV, MP3 of andere ondersteunde formaten)
• Maximaal 5 kanalen per audiobestand
• Elk kanaal mag slechts één spreker bevatten

Zo werkt het

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

Implementatie

Eenvoudige transcriptie met meerdere kanalen

Hier is een volledig voorbeeld van het transcriberen van een stereo-audiobestand met twee sprekers:

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}")

Gesprekstranscripten maken

De eenvoudigste manier om een transcript in gespreksstijl op tijdvolgorde te krijgen, is multichannel_output_style=combined aan te vragen — de API retourneert één words-lijst, al gesorteerd op starttijd, met een channel_index en speaker_id bij elk woord:

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}")

Als je de standaarduitvoer separate gebruikt, kun je de transcripten per kanaal in plaats daarvan client-side samenvoegen:

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']}")

Webhooks gebruiken met meerdere kanalen

Transcriptie met meerdere kanalen ondersteunt webhooklevering voor asynchrone verwerking:

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

Foutafhandeling

Veelvoorkomende validatiefouten

Best practices

Audio voorbereiden

Prestaties optimaliseren

De concurrencykosten nemen lineair toe met het aantal kanalen. Een bestand van 60 seconden met 3 kanalen heeft 3x de concurrencykosten van een bestand met één kanaal.

Je kunt de verwerkingstijd voor audio met meerdere kanalen schatten met de volgende formule:

Waarbij:

• $D$ = bestandsduur in seconden
• $N$ = aantal kanalen
• $0.3$ = verwerkingssnelheidsfactor (ongeveer 30% van realtime)
• $2$ = vaste overhead in seconden
• $0.5$ = overhead per kanaal in seconden

Voorbeeld: Voor een stereobestand van 60 seconden (2 kanalen):

Overwegingen voor geheugen

Overweeg voor grote bestanden met meerdere kanalen streaming of chunking:

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

Veelgestelde vragen

Volgende stappen