Mehrkanal-Speech-to-Text

Überblick

Mit der Mehrkanal-Funktion von Speech to Text können Sie Audiodateien transkribieren, bei denen jeder Kanal einen eigenen Sprecher enthält. Das ist besonders für Aufnahmen nützlich, bei denen Sprecher auf separaten Audiokanälen isoliert sind. So erhalten Sie sauberere Transkriptionen ohne Sprecherdiarisierung.

Jeder Kanal wird unabhängig verarbeitet und anhand seiner Kanalnummer automatisch einer Sprecher-ID zugeordnet (Kanal 0 → speaker_0, Kanal 1 → speaker_1 usw.). Das System extrahiert die einzelnen Kanäle aus Ihrer Eingabe-Audiodatei und transkribiert sie parallel. Standardmäßig gibt die API ein Transkript pro Kanal zurück. Legen Sie stattdessen multichannel_output_style=combined fest, um ein einzelnes Transkript mit allen Kanälen in einer nach Startzeit sortierten Liste zu erhalten, wobei jedes Wort mit seinem channel_index gekennzeichnet ist.

Häufige Anwendungsfälle

• Stereo-Interviewaufnahmen – Interviewer auf dem linken Kanal, Interviewte Person auf dem rechten Kanal
• Mehrspurige Podcast-Aufnahmen – Jeder Teilnehmer wird auf einer separaten Spur aufgenommen
• Callcenter-Aufnahmen – Agent und Kunde auf unterschiedlichen Kanälen
• Konferenzaufnahmen – Einzelne Teilnehmer auf separaten Kanälen isoliert
• Gerichtsverfahren – Mehrere Parteien auf unterschiedlichen Kanälen aufgezeichnet

Anforderungen

• Ein ElevenLabs-Konto mit einem API-Schlüssel
• Mehrkanal-Audiodatei (WAV, MP3 oder andere unterstützte Formate)
• Maximal 5 Kanäle pro Audiodatei
• Jeder Kanal sollte nur einen Sprecher enthalten

Funktionsweise

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

Implementierung

Einfache Mehrkanal-Transkription

Hier ist ein vollständiges Beispiel für die Transkription einer Stereo-Audiodatei mit zwei Sprechern:

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

Gesprächstranskripte erstellen

Am einfachsten erhalten Sie ein nach Zeit geordnetes Transkript im Gesprächsstil, indem Sie multichannel_output_style=combined anfordern. Die API gibt eine einzelne words-Liste zurück, die bereits nach Startzeit sortiert ist und bei jedem Wort einen channel_index und speaker_id enthält:

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

Wenn Sie die Standardausgabe separate verwenden, können Sie die Transkripte pro Kanal stattdessen clientseitig zusammenführen:

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 mit Mehrkanal verwenden

Die Mehrkanal-Transkription unterstützt die Webhook-Bereitstellung für die asynchrone Verarbeitung:

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

Fehlerbehandlung

Häufige Validierungsfehler

Best Practices

Audio vorbereiten

Leistung optimieren

Die Parallelitätskosten steigen linear mit der Anzahl der Kanäle. Eine 60-sekündige Datei mit 3 Kanälen verursacht die dreifachen Parallelitätskosten einer einkanaligen Datei.

Sie können die Verarbeitungszeit für Mehrkanal-Audio mit der folgenden Formel schätzen:

Dabei gilt:

• $D$ = Dateidauer in Sekunden
• $N$ = Anzahl der Kanäle
• $0.3$ = Faktor für die Verarbeitungsgeschwindigkeit (etwa 30 % der Echtzeit)
• $2$ = fester Overhead in Sekunden
• $0.5$ = Overhead pro Kanal in Sekunden

Beispiel: Für eine 60-sekündige Stereo-Datei (2 Kanäle):

Speicheraspekte

Bei großen Mehrkanaldateien sollten Sie Streaming oder Aufteilung in Chunks erwägen:

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

Nächste Schritte