Speech to Text multicanale

Panoramica

La funzionalità Speech to Text multicanale ti consente di trascrivere file audio in cui ciascun canale contiene un interlocutore distinto. È particolarmente utile per le registrazioni in cui gli interlocutori sono isolati su canali audio separati, offrendo trascrizioni più pulite senza necessità di diarizzazione degli interlocutori.

Ogni canale viene elaborato in modo indipendente e riceve automaticamente un ID interlocutore in base al suo numero di canale (canale 0 → speaker_0, canale 1 → speaker_1 e così via). Il sistema estrae i singoli canali dal file audio di input e li trascrive in parallelo. Per impostazione predefinita, l’API restituisce una trascrizione per canale; imposta multichannel_output_style=combined per ricevere invece un’unica trascrizione con tutti i canali uniti in un elenco ordinato per ora di inizio, con ogni parola contrassegnata dal relativo channel_index.

Casi d’uso comuni

• Registrazioni di interviste stereo - Intervistatore sul canale sinistro, intervistato sul canale destro
• Registrazioni di podcast multitraccia - Ogni partecipante registrato su una traccia separata
• Registrazioni di call center - Agente e cliente separati su canali diversi
• Registrazioni di conferenze - Singoli partecipanti isolati su canali separati
• Procedimenti giudiziari - Più parti registrate su canali distinti

Requisiti

• Un account ElevenLabs con una chiave API
• File audio multicanale (WAV, MP3 o altri formati supportati)
• Massimo 5 canali per file audio
• Ogni canale deve contenere un solo interlocutore

Come funziona

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

Implementazione

Trascrizione multicanale di base

Ecco un esempio completo per trascrivere un file audio stereo con due interlocutori:

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

Creazione di trascrizioni conversazionali

Il modo più semplice per ottenere una trascrizione in stile conversazione, ordinata nel tempo, è richiedere multichannel_output_style=combined: l’API restituisce un unico elenco words, già ordinato per ora di inizio, con un channel_index e speaker_id su ogni parola:

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 utilizzi l’output separate predefinito, puoi invece unire lato client le trascrizioni per canale:

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

Utilizzo dei webhook con il multicanale

La trascrizione multicanale supporta la consegna tramite webhook per l’elaborazione asincrona:

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

Gestione degli errori

Errori di convalida comuni

Best practice

Preparazione dell’audio

Ottimizzazione delle prestazioni

Il costo di concorrenza aumenta linearmente con il numero di canali. Un file di 60 secondi con 3 canali ha un costo di concorrenza 3 volte superiore rispetto a un file a canale singolo.

Puoi stimare il tempo di elaborazione per l’audio multicanale usando la seguente formula:

Dove:

• $D$ = durata del file in secondi
• $N$ = numero di canali
• $0.3$ = fattore di velocità di elaborazione (circa il 30% del tempo reale)
• $2$ = overhead fisso in secondi
• $0.5$ = overhead per canale in secondi

Esempio: Per un file stereo di 60 secondi (2 canali):

Considerazioni sulla memoria

Per file multicanale di grandi dimensioni, valuta lo streaming o la suddivisione in blocchi:

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

Passaggi successivi