Speech to Text multicanal

Visão geral

O recurso multicanal de Speech to Text permite transcrever arquivos de áudio em que cada canal contém um falante distinto. Isso é especialmente útil para gravações em que os falantes estão isolados em canais de áudio separados, proporcionando transcrições mais limpas sem a necessidade de diarização de falantes.

Cada canal é processado de forma independente e recebe automaticamente um ID de falante com base no número do canal (canal 0 → speaker_0, canal 1 → speaker_1 etc.). O sistema extrai canais individuais do seu arquivo de áudio de entrada e os transcreve em paralelo. Por padrão, a API retorna uma transcrição por canal; defina multichannel_output_style=combined para receber uma única transcrição com todos os canais combinados em uma lista ordenada pelo horário de início, com cada palavra identificada pelo seu channel_index.

Casos de uso comuns

• Gravações de entrevistas em estéreo - Entrevistador no canal esquerdo, entrevistado no canal direito
• Gravações de podcasts com várias faixas - Cada participante gravado em uma faixa separada
• Gravações de central de atendimento - Atendente e cliente separados em canais diferentes
• Gravações de conferências - Participantes individuais isolados em canais separados
• Processos judiciais - Várias partes gravadas em canais distintos

Requisitos

• Uma conta ElevenLabs com uma chave de API
• Arquivo de áudio multicanal (WAV, MP3 ou outros formatos compatíveis)
• Máximo de 5 canais por arquivo de áudio
• Cada canal deve conter apenas um falante

Como funciona

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

Implementação

Transcrição multicanal básica

Este é um exemplo completo de transcrição de um arquivo de áudio estéreo com dois falantes:

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

Criação de transcrições de conversas

A maneira mais fácil de obter uma transcrição de conversa ordenada cronologicamente é solicitar multichannel_output_style=combined — a API retorna uma única lista de words, já ordenada pelo horário de início, com um channel_index e speaker_id em cada palavra:

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

Se você estiver usando a saída padrão separate, também pode combinar as transcrições por canal no cliente:

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

Uso de webhooks com multicanal

A transcrição multicanal é compatível com a entrega por webhook para processamento assíncrono:

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

Tratamento de erros

Erros de validação comuns

Boas práticas

Preparação do áudio

Otimização de desempenho

O custo de simultaneidade aumenta linearmente com o número de canais. Um arquivo de 60 segundos com 3 canais tem um custo de simultaneidade 3 vezes maior que o de um arquivo de canal único.

Você pode estimar o tempo de processamento de áudio multicanal usando a seguinte fórmula:

Em que:

• $D$ = duração do arquivo em segundos
• $N$ = número de canais
• $0.3$ = fator de velocidade de processamento (aproximadamente 30% do tempo real)
• $2$ = sobrecarga fixa em segundos
• $0.5$ = sobrecarga por canal em segundos

Exemplo: Para um arquivo estéreo de 60 segundos (2 canais):

Considerações sobre memória

Para arquivos multicanal grandes, considere fazer streaming ou dividir em partes:

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

Perguntas frequentes

Próximas etapas