Voz a Texto multicanal

Resumen

La función de Voz a Texto multicanal te permite transcribir archivos de audio en los que cada canal contiene un hablante distinto. Es especialmente útil para grabaciones en las que los hablantes están aislados en canales de audio independientes, ya que ofrece transcripciones más limpias sin necesidad de diarización de hablantes.

Cada canal se procesa de forma independiente y se le asigna automáticamente un ID de hablante según su número de canal (canal 0 → speaker_0, canal 1 → speaker_1, etc.). El sistema extrae canales individuales de tu archivo de audio de entrada y los transcribe en paralelo. De forma predeterminada, la API devuelve una transcripción por canal; configura multichannel_output_style=combined para recibir una única transcripción con todos los canales combinados en una lista ordenada por hora de inicio, con cada palabra etiquetada con su channel_index.

Casos de uso habituales

• Grabaciones de entrevistas en estéreo - Entrevistador en el canal izquierdo y entrevistado en el derecho
• Grabaciones de podcasts multipista - Cada participante grabado en una pista independiente
• Grabaciones de centros de llamadas - Agente y cliente separados en canales diferentes
• Grabaciones de conferencias - Participantes individuales aislados en canales independientes
• Procedimientos judiciales - Varias partes grabadas en canales distintos

Requisitos

• Una cuenta de ElevenLabs con una clave de API
• Archivo de audio multicanal (WAV, MP3 u otros formatos compatibles)
• Máximo de 5 canales por archivo de audio
• Cada canal debe contener un solo hablante

Cómo funciona

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

Implementación

Transcripción multicanal básica

Aquí tienes un ejemplo completo para transcribir un archivo de audio estéreo con dos hablantes:

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

Crear transcripciones de conversaciones

La forma más sencilla de obtener una transcripción ordenada por tiempo y al estilo de una conversación es solicitar multichannel_output_style=combined: la API devuelve una única lista words, ya ordenada por hora de inicio, con un channel_index y un speaker_id en cada palabra:

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

Si utilizas la salida separate predeterminada, puedes combinar las transcripciones por canal en el 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']}")

Usar webhooks con multicanal

La transcripción multicanal admite entrega mediante webhook para el procesamiento así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

Gestión de errores

Errores de validación habituales

Buenas prácticas

Preparación del audio

Optimización del rendimiento

El coste de concurrencia aumenta linealmente con el número de canales. Un archivo de 60 segundos con 3 canales tiene un coste de concurrencia 3 veces mayor que un archivo de un solo canal.

Puedes estimar el tiempo de procesamiento del audio multicanal mediante la siguiente fórmula:

Donde:

• $D$ = duración del archivo en segundos
• $N$ = número de canales
• $0.3$ = factor de velocidad de procesamiento (aproximadamente el 30 % del tiempo real)
• $2$ = sobrecarga fija en segundos
• $0.5$ = sobrecarga por canal en segundos

Ejemplo: Para un archivo estéreo de 60 segundos (2 canales):

Consideraciones de memoria

Para archivos multicanal grandes, considera la transmisión o la división en fragmentos:

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

Preguntas frecuentes

Siguientes pasos