Flerkanalig tal-till-text

Översikt

Den flerkanaliga Speech to Text-funktionen låter dig transkribera ljudfiler där varje kanal innehåller en egen talare. Det är särskilt användbart för inspelningar där talare är isolerade på separata ljudkanaler, vilket ger renare transkriberingar utan behov av talardiarisering.

Varje kanal bearbetas oberoende och tilldelas automatiskt ett talar-ID baserat på kanalnumret (kanal 0 → speaker_0, kanal 1 → speaker_1 osv.). Systemet extraherar enskilda kanaler från din ingående ljudfil och transkriberar dem parallellt. Som standard returnerar API:t en transkribering per kanal. Ange multichannel_output_style=combined för att i stället få en enda transkribering där alla kanaler är sammanfogade till en lista sorterad efter starttid, med varje ord märkt med sitt channel_index.

Vanliga användningsfall

• Stereoinspelade intervjuer - Intervjuare på vänster kanal, intervjuad på höger kanal
• Poddinspelningar med flera spår - Varje deltagare spelas in på ett separat spår
• Inspelningar från kundtjänstcenter - Agent och kund på olika kanaler
• Konferensinspelningar - Enskilda deltagare isolerade på separata kanaler
• Domstolsförhandlingar - Flera parter spelas in på separata kanaler

Krav

• Ett ElevenLabs-konto med en API-nyckel
• Flerkanalig ljudfil (WAV, MP3 eller andra format som stöds)
• Högst 5 kanaler per ljudfil
• Varje kanal ska endast innehålla en talare

Så fungerar det

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

Implementering

Grundläggande flerkanalig transkribering

Här är ett komplett exempel på hur du transkriberar en stereoljudfil med två talare:

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

Skapa konversationstranskriberingar

Det enklaste sättet att få en tidsordnad transkribering i konversationsstil är att begära multichannel_output_style=combined — API:t returnerar en enda words-lista, redan sorterad efter starttid, med ett channel_index och speaker_id för varje ord:

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

Om du använder standardutdata separate kan du i stället sammanfoga transkriberingarna per kanal på klientsidan:

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

Använda webhooks med flera kanaler

Flerkanalig transkribering stöder webhook-leverans för asynkron bearbetning:

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

Felhantering

Vanliga valideringsfel

Bästa praxis

Förbereda ljud

Prestandaoptimering

Kostnaden för samtidighet ökar linjärt med antalet kanaler. En fil på 60 sekunder med 3 kanaler har tre gånger så hög samtidighetskostnad som en fil med en kanal.

Du kan uppskatta bearbetningstiden för flerkanaligt ljud med följande formel:

Där:

• $D$ = filens längd i sekunder
• $N$ = antal kanaler
• $0.3$ = bearbetningshastighetsfaktor (cirka 30 % av realtid)
• $2$ = fast omkostnad i sekunder
• $0.5$ = omkostnad per kanal i sekunder

Exempel: För en stereofil på 60 sekunder (2 kanaler):

Minneshantering

För stora flerkanaliga filer bör du överväga streaming eller uppdelning i segment:

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

Vanliga frågor

Nästa steg