Hoppa till navigering

Flerkanalig tal-till-text

Den här guiden visar hur du använder flerkanaligt transkriberingsläge med Speech to Text API:t.

Guide · Förutsätter att du har slutfört snabbstartsguiden för Speech to Text .

Översikt

Funktionen för flerkanalig Speech to Text låter dig transkribera ljudfiler där varje kanal innehåller en separat talare. Det är särskilt användbart för inspelningar där talare är isolerade på olika ljudkanaler och ger renare transkriberingar utan behov av talarseparering.

Varje kanal behandlas 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 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 sammanfogas till en lista sorterad efter starttid, med varje ord märkt med sitt channel_index.

Vanliga användningsfall

  • Stereoinspelningar av intervjuer - Intervjuaren på vänster kanal, intervjuobjektet på höger kanal
  • Podcasts med flera spår - Varje deltagare spelas in på ett separat spår
  • Inspelningar från callcenter - Agent och kund separerade på olika kanaler
  • Konferensinspelningar - Enskilda deltagare isolerade på separata kanaler
  • Domstolsförhandlingar - Flera parter inspelade på olika 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 innehålla endast en talare

Så fungerar det

1

Förbered ditt flerkanaliga ljud

Kontrollera att talarna i din ljudfil är isolerade på separata kanaler. Flerkanalsfunktionen har stöd för upp till 5 kanaler, där varje kanal mappas till en specifik talare:

  • Kanal 0 → speaker_0
  • Kanal 1 → speaker_1
  • Kanal 2 → speaker_2
  • Kanal 3 → speaker_3
  • Kanal 4 → speaker_4
2

Konfigurera API-parametrar

När du gör en tal-till-text-begäran måste du ange:

  • use_multi_channel: true
  • diarize: false (flerkanalsläget hanterar talarseparering via kanaler)

Du kan även styra svarsformatet med:

  • multichannel_output_style: separate (standard) returnerar en transkribering per kanal. combined sammanfogar alla kanaler till en enda transkribering vars ord är sorterade efter starttid och där varje ord har ett channel_index — samma format som standardsvaret för en enskild kanal. combined kräver tidsstämplar (timestamps_granularity får inte vara none) och stöds inte med webhook-leverans eller entitetsidentifiering/-maskering.

Parametern num_speakers kan inte användas med flerkanalsläget eftersom antalet talare bestäms automatiskt av antalet kanaler. Flerkanalsläget förutsätter att det finns exakt en talare per kanal. Om det finns fler tilldelas alla talare i kanalen samma talar-ID.

3

Behandla svaret

Som standard (multichannel_output_style=separate) returnerar flerkanaligt ljud ett annat svarsformat än ljud med en enda kanal:

Om du anger use_multi_channel: true men tillhandahåller en enkanalig ljudfil (mono) får du ett standardsvar för en kanal, inte flerkanalsformatet. Flerkanalssvarsformatet returneras endast när ljudfilen faktiskt innehåller flera kanaler.

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

Med multichannel_output_style=combined använder svaret samma platta format som en transkribering för en kanal (överordnade text och words, ingen transcripts-array), där alla kanaler är sammanfogade till en lista sorterad efter starttid. Varje ord innehåller ett channel_index (och speaker_id) som identifierar dess kanal.

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

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:

Kombinerad utdata (rekommenderas)
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}")

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 har stöd för webhook-leverans för asynkron bearbetning:

Webhooks returnerar formatet separate (per kanal). multichannel_output_style=combined stöds för närvarande inte med webhook-leverans — använd en synkron begäran eller sammanfoga webhook- payloaden per kanal på klientsidan.

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

Felhantering

Vanliga valideringsfel

Fel: Flerkanalsläget har inte stöd för talarseparering och tilldelar talare utifrån den kanal de talar i.

Lösning: Ange alltid diarize=false när du använder flerkanalsläge.

Fel: Det går inte att ange num_speakers när use_multi_channel är aktiverat. Antalet talare bestäms automatiskt av antalet kanaler. Lösning: Ta bort parametern num_speakers från din begäran.

Fel: Flerkanalsläget har stöd för upp till 5 kanaler, men ljudfilen innehåller X kanaler.

Lösning: Bearbeta endast de första 5 kanalerna eller förbehandla ljudet för att minska antalet kanaler.

Fel: multichannel_output_style=‘combined’ kräver tidsstämplar; ange timestamps_granularity till ‘word’ eller ‘character’.

Lösning: Kombinerad utdata sorterar ord efter tid, så ange timestamps_granularity till word (standard) eller character.

Fel: multichannel_output_style=‘combined’ stöds ännu inte med webhook-leverans.

Lösning: Använd en synkron begäran med combined, eller behåll standardutdata separate när du använder webhooks och sammanfoga på klientsidan.

Bästa praxis

Förbereda ljudet

För bästa resultat: - Använd en samplingsfrekvens på 16 kHz för bättre prestanda - Ta bort tysta eller oanvända kanaler före bearbetning - Kontrollera att varje kanal bara innehåller en talare - Använd om möjligt förlustfria format (WAV) för bästa kvalitet

Prestandaoptimering

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

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

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

Där:

  • DD = filens längd i sekunder
  • NN = antal kanaler
  • 0.30.3 = faktor för bearbetningshastighet (ungefär 30 % av realtid)
  • 22 = fast overhead i sekunder
  • 0.50.5 = overhead per kanal i sekunder

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

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

Minnesöverväganden

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_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

Vanliga frågor

API:t returnerar ett fel. Du måste antingen välja vilka 5 kanaler som ska skickas till API:t eller mixa ned vissa kanaler innan du skickar dem till API:t.

Ja, men det är onödigt. Om du skickar monoljud med use_multi_channel=true får du ett standardsvar för en kanal, inte flerkanalsformatet.

Ja. Ange multichannel_output_style=combined för att få en enda transkribering där alla kanaler är sammanfogade och sorterade efter starttid, med varje ord märkt med sitt channel_index. Detta motsvarar standardsvarsformatet för en kanal. Det kräver tidsstämplar och är inte tillgängligt med webhook- leverans.

Talar-ID:n är deterministiska utifrån kanalnummer: kanal 0 blir speaker_0, kanal 1 blir speaker_1 och så vidare.

Ja, varje kanal behandlas oberoende och kan identifiera olika språk. Språkidentifieringen sker per kanal. Med multichannel_output_style=combined återspeglar överordnade language_code kanalen med högst säkerhet, medan varje ord fortfarande har sitt channel_index.

Nästa steg