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 locuteur distinct. Elle est particulièrement utile pour les enregistrements dans lesquels les locuteurs sont isolés sur des canaux audio séparés, afin d’obtenir des transcriptions plus propres sans recourir à la diarisation des locuteurs.

Chaque canal est traité indépendamment et reçoit automatiquement un identifiant de locuteur 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 seule transcription 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 : interviewer 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 individuels 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 autres formats pris en charge)
• Maximum 5 canaux par fichier audio
• Chaque canal ne doit contenir qu’un seul locuteur

Fonctionnement

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

Mise en œuvre

Transcription multicanal de base

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

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

Création de transcriptions de conversation

Le moyen le plus simple d’obtenir une transcription de conversation triée par heure est de 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_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 vous utilisez la sortie separate par défaut, vous pouvez plutôt fusionner côté client les transcriptions par 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 mode 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_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

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 coûte 3 fois plus en requêtes simultanées qu’un fichier à un seul canal.

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 liées à la mémoire

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

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

FAQ

Étapes suivantes