Wielokanałowa zamiana mowy na tekst

Omówienie

Wielokanałowa funkcja Speech to Text umożliwia transkrypcję plików audio, w których każdy kanał zawiera głos innego mówcy. Jest szczególnie przydatna w nagraniach, gdzie mówcy są odseparowani na osobnych kanałach audio, zapewniając czystsze transkrypcje bez diarizacji mówców.

Każdy kanał jest przetwarzany niezależnie i automatycznie otrzymuje ID mówcy na podstawie numeru kanału (kanał 0 → speaker_0, kanał 1 → speaker_1 itd.). System wyodrębnia poszczególne kanały z wejściowego pliku audio i transkrybuje je równolegle. Domyślnie API zwraca jedną transkrypcję na kanał; ustaw multichannel_output_style=combined, aby otrzymać jedną transkrypcję ze wszystkimi kanałami połączonymi w jedną listę posortowaną według czasu rozpoczęcia, z każdym słowem oznaczonym przez channel_index.

Typowe zastosowania

• Nagrania wywiadów stereo — prowadzący w lewym kanale, rozmówca w prawym
• Wielokanałowe nagrania podcastów — każdy uczestnik nagrany na osobnej ścieżce
• Nagrania call center — agent i klient na różnych kanałach
• Nagrania konferencji — poszczególni uczestnicy odseparowani na osobnych kanałach
• Postępowania sądowe — wiele stron nagranych na odrębnych kanałach

Wymagania

• Konto ElevenLabs z kluczem API
• Wielokanałowy plik audio (WAV, MP3 lub inny obsługiwany format)
• Maksymalnie 5 kanałów na plik audio
• Każdy kanał powinien zawierać tylko jednego mówcę

Jak to działa

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

Implementacja

Podstawowa transkrypcja wielokanałowa

Oto pełny przykład transkrypcji pliku audio stereo z dwoma mówcami:

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

Tworzenie transkrypcji rozmów

Najprostszy sposób na uzyskanie transkrypcji rozmowy uporządkowanej w czasie to zażądanie multichannel_output_style=combined — API zwraca jedną listę words, już posortowaną według czasu rozpoczęcia, z channel_index i speaker_id przy każdym słowie:

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

Jeśli używasz domyślnego wyniku separate, możesz zamiast tego połączyć transkrypcje poszczególnych kanałów po stronie klienta:

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

Korzystanie z webhooków w trybie wielokanałowym

Wielokanałowa transkrypcja obsługuje dostarczanie przez webhook do przetwarzania asynchronicznego:

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

Obsługa błędów

Częste błędy walidacji

Dobre praktyki

Przygotowanie audio

Optymalizacja wydajności

Koszt współbieżności rośnie liniowo wraz z liczbą kanałów. Trzykanałowy plik o długości 60 sekund ma 3 razy większy koszt współbieżności niż plik jednokanałowy.

Czas przetwarzania audio wielokanałowego możesz oszacować za pomocą następującego wzoru:

Gdzie:

• $D$ = czas trwania pliku w sekundach
• $N$ = liczba kanałów
• $0.3$ = współczynnik szybkości przetwarzania (około 30% czasu rzeczywistego)
• $2$ = stały narzut w sekundach
• $0.5$ = narzut na kanał w sekundach

Przykład: dla 60-sekundowego pliku stereo (2 kanały):

Kwestie pamięci

W przypadku dużych plików wielokanałowych rozważ strumieniowanie lub dzielenie na fragmenty:

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

FAQ

Kolejne kroki