Speech to Text multicanal

Vue d’ensemble

La fonctionnalité Speech to Text multicanal vous permet de transcrire des fichiers audio dont chaque canal contient un intervenant distinct. Elle est particulièrement utile pour les enregistrements où les intervenants sont isolés sur des canaux audio séparés, afin d’obtenir des transcriptions plus nettes sans recourir à la diarisation des intervenants.

Chaque canal est traité indépendamment et reçoit automatiquement un ID d’intervenant selon son numéro de canal (canal 0 → speaker_0, canal 1 → speaker_1, etc.). Le système extrait les différents canaux de votre fichier audio d’entrée et les transcrit en parallèle. Par défaut, l’API renvoie une transcription par canal ; définissez multichannel_output_style=combined pour recevoir à la place une transcription unique regroupant tous les canaux dans une liste triée par heure de début, chaque mot étant étiqueté avec son channel_index.

Cas d’utilisation courants

• Enregistrements d’entretiens stéréo : enquêteur sur le canal gauche, personne interrogée sur le canal droit
• Enregistrements de podcasts multipistes : chaque participant est enregistré sur une piste distincte
• Enregistrements de centres d’appels : agent et client séparés sur différents canaux
• Enregistrements de conférences : participants isolés sur des canaux distincts
• Procédures judiciaires : plusieurs parties enregistrées sur des canaux distincts

Prérequis

• Un compte ElevenLabs avec une clé API
• Un fichier audio multicanal (WAV, MP3 ou autre format pris en charge)
• Maximum 5 canaux par fichier audio
• Chaque canal ne doit contenir qu’un seul intervenant

Fonctionnement

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

Implémentation

Transcription multicanal de base

Voici un exemple complet de transcription d’un fichier audio stéréo avec deux intervenants :

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

Création de transcriptions de conversations

La manière la plus simple d’obtenir une transcription de conversation classée par heure consiste à demander multichannel_output_style=combined : l’API renvoie une seule liste words, déjà triée par heure de début, avec un channel_index et un speaker_id pour chaque mot :

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

Si vous utilisez la sortie separate par défaut, vous pouvez à la place fusionner côté client les transcriptions de chaque canal :

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

Utiliser des webhooks avec le multicanal

La transcription multicanal prend en charge la livraison par webhook pour le traitement asynchrone :

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

Gestion des erreurs

Erreurs de validation courantes

Bonnes pratiques

Préparation de l’audio

Optimisation des performances

Le coût en requêtes simultanées augmente linéairement avec le nombre de canaux. Un fichier de 60 secondes comportant 3 canaux représente un coût en requêtes simultanées trois fois supérieur à celui d’un fichier monocanal.

Vous pouvez estimer le temps de traitement d’un audio multicanal à l’aide de la formule suivante :

Où :

• $D$ = durée du fichier en secondes
• $N$ = nombre de canaux
• $0.3$ = facteur de vitesse de traitement (environ 30 % du temps réel)
• $2$ = surcharge fixe en secondes
• $0.5$ = surcharge par canal en secondes

Exemple : pour un fichier stéréo de 60 secondes (2 canaux) :

Considérations relatives à la mémoire

Pour les fichiers multicanaux volumineux, envisagez le streaming ou le découpage en fragments :

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

Étapes suivantes