Rileva diversi altoparlanti in una registrazione audio

In questa pagina viene descritto come trovare le etichette di diversi altoparlanti nell'audio dati trascritti da Speech-to-Text.

A volte, i dati audio contengono campioni di più persone che parlano. Ad esempio, l'audio di una telefonata solitamente include voci di due o più persone. Una trascrizione della chiamata dovrebbe includere chi parla e quando.

Diarizzazione degli speaker

Speech-to-Text è in grado di riconoscere più interlocutori che parlano nello stesso clip audio. Quando invii una richiesta di trascrizione audio a Speech-to-Text, puoi includere un parametro che indica a Speech-to-Text di identificare i diversi interlocutori nel campione audio. Questa funzionalità, chiamata diarizzazione degli interlocutori, rileva quando cambiano le persone che parlano ed etichetta con un numero le singole voci rilevate nell'audio.

Quando attivi la diarizzazione nella richiesta di trascrizione, Speech-to-Text tenta di distinguere le diverse voci incluse nel campione audio. La il risultato della trascrizione contrassegna ogni parola con un numero singoli speaker. Le parole pronunciate dallo stesso oratore hanno la stessa numero. Il risultato di una trascrizione può includere numeri fino a un massimo di di riconoscimento vocale come Speech-to-Text possono identificare in modo univoco audio di esempio.

Quando utilizzi la diarizzazione degli speaker, Speech-to-Text produce un insieme aggregato di tutti i risultati forniti nella trascrizione. Ogni risultato include le parole del risultato precedente. Di conseguenza, words un array nel risultato finale fornisce i risultati completi e diarizzati della trascrizione.

Consulta la pagina di assistenza relativa alle lingue per scoprire se questa funzione è disponibile nella tua lingua.

Attiva la diarizzazione dello speaker in una richiesta

Per attivare la diarizzazione dell'interlocutore, devi impostare il campo diarization_config in RecognitionFeatures. Devi impostare i valori min_speaker_count e max_speaker_count in base al numero di speaker che prevedi nella trascrizione.

Speech-to-Text supporta l'altoparlante diarizzazione per tutti i metodi di riconoscimento vocale: speech:recognize e Streaming.

Utilizzare un file locale

Il seguente snippet di codice mostra come attivare il relatore diarizzazione in una richiesta di trascrizione a Speech-to-Text utilizzando un file locale

Protocollo

Fai riferimento all'endpoint API speech:recognize per i dettagli completi.

Per eseguire il riconoscimento vocale sincrono, effettua una richiesta POST e fornisci il corpo della richiesta appropriato. Di seguito è riportato un esempio di richiesta POST che utilizza curl. L'esempio utilizza Google Cloud CLI per generare un token di accesso. Per istruzioni sull'installazione di gcloud CLI, consulta la guida rapida.

curl -s -H "Content-Type: application/json" \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
    https://speech.googleapis.com/v2/projects/{project}/locations/{location}/recognizers/{recognizer}:recognize \
    --data '{
    "config": {
        "features": {
            "diarizationConfig": {
              "minSpeakerCount": 2,
              "maxSpeakerCount": 2
            },
        }
    },
    "uri": "gs://cloud-samples-tests/speech/commercial_mono.wav"
}' > speaker-diarization.txt

Se la richiesta riesce, il server restituisce un codice di stato HTTP 200 OK e la risposta in formato JSON, salvata in un file denominato speaker-diarization.txt.

{
  "results": [
    {
      "alternatives": [
        {
          "transcript": "hi I'd like to buy a Chromecast and I was wondering whether you could help me with that certainly which color would you like we have blue black and red uh let's go with the black one would you like the new Chromecast Ultra model or the regular Chrome Cast regular Chromecast is fine thank you okay sure we like to ship it regular or Express Express please terrific it's on the way thank you thank you very much bye",
          "confidence": 0.92142606,
          "words": [
            {
              "startOffset": "0s",
              "endOffset": "1.100s",
              "word": "hi",
              "speakerLabel": "2"
            },
            {
              "startOffset": "1.100s",
              "endOffset": "2s",
              "word": "I'd",
              "speakerLabel": "2"
            },
            {
              "startOffset": "2s",
              "endOffset": "2s",
              "word": "like",
              "speakerLabel": "2"
            },
            {
              "startOffset": "2s",
              "endOffset": "2.100s",
              "word": "to",
              "speakerLabel": "2"
            },
            ...
            {
              "startOffset": "6.500s",
              "endOffset": "6.900s",
              "word": "certainly",
              "speakerLabel": "1"
            },
            {
              "startOffset": "6.900s",
              "endOffset": "7.300s",
              "word": "which",
              "speakerLabel": "1"
            },
            {
              "startOffset": "7.300s",
              "endOffset": "7.500s",
              "word": "color",
              "speakerLabel": "1"
            },
            ...
          ]
        }
      ],
      "languageCode": "en-us"
    }
  ]
}

Go

Per scoprire come installare e utilizzare la libreria client per Speech-to-Text, consulta Librerie client di Speech-to-Text. Per ulteriori informazioni, consulta API Go Speech-to-Text documentazione di riferimento.

Per eseguire l'autenticazione a Speech-to-Text, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

import (
	"context"
	"fmt"
	"io"
	"os"
	"strings"

	speech "cloud.google.com/go/speech/apiv1"
	"cloud.google.com/go/speech/apiv1/speechpb"
)

// transcribe_diarization_gcs_beta Transcribes a remote audio file using speaker diarization.
func transcribe_diarization(w io.Writer) error {

	ctx := context.Background()
	client, err := speech.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient: %w", err)
	}
	defer client.Close()

	diarizationConfig := &speechpb.SpeakerDiarizationConfig{
		EnableSpeakerDiarization: true,
		MinSpeakerCount:          2,
		MaxSpeakerCount:          2,
	}

	recognitionConfig := &speechpb.RecognitionConfig{
		Encoding:          speechpb.RecognitionConfig_LINEAR16,
		SampleRateHertz:   8000,
		LanguageCode:      "en-US",
		DiarizationConfig: diarizationConfig,
	}

	// Get the contents of the local audio file
	content, err := os.ReadFile("../resources/commercial_mono.wav")
	if err != nil {
		return fmt.Errorf("error reading file %w", err)
	}
	audio := &speechpb.RecognitionAudio{
		AudioSource: &speechpb.RecognitionAudio_Content{Content: content},
	}

	longRunningRecognizeRequest := &speechpb.LongRunningRecognizeRequest{
		Config: recognitionConfig,
		Audio:  audio,
	}

	operation, err := client.LongRunningRecognize(ctx, longRunningRecognizeRequest)
	if err != nil {
		return fmt.Errorf("error running recognize %w", err)
	}

	response, err := operation.Wait(ctx)
	if err != nil {
		return err
	}

	// Speaker Tags are only included in the last result object, which has only one
	// alternative.
	alternative := response.Results[len(response.Results)-1].Alternatives[0]

	wordInfo := alternative.GetWords()[0]
	currentSpeakerTag := wordInfo.GetSpeakerTag()

	var speakerWords strings.Builder

	speakerWords.WriteString(fmt.Sprintf("Speaker %d: %s", wordInfo.GetSpeakerTag(), wordInfo.GetWord()))

	// For each word, get all the words associated with one speaker, once the speaker changes,
	// add a new line with the new speaker and their spoken words.
	for i := 1; i < len(alternative.Words); i++ {
		wordInfo := alternative.Words[i]
		if currentSpeakerTag == wordInfo.GetSpeakerTag() {
			speakerWords.WriteString(" ")
			speakerWords.WriteString(wordInfo.GetWord())
		} else {
			speakerWords.WriteString(fmt.Sprintf("\nSpeaker %d: %s",
				wordInfo.GetSpeakerTag(), wordInfo.GetWord()))
			currentSpeakerTag = wordInfo.GetSpeakerTag()
		}
	}
	fmt.Fprintf(w, speakerWords.String())
	return nil
}

Python

Per scoprire come installare e utilizzare la libreria client per Speech-to-Text, consulta Librerie client di Speech-to-Text. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Speech-to-Text Python.

Per autenticarti a Speech-to-Text, configura le credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

from google.cloud import speech_v1p1beta1 as speech

client = speech.SpeechClient()

speech_file = "resources/commercial_mono.wav"

with open(speech_file, "rb") as audio_file:
    content = audio_file.read()

audio = speech.RecognitionAudio(content=content)

diarization_config = speech.SpeakerDiarizationConfig(
    enable_speaker_diarization=True,
    min_speaker_count=2,
    max_speaker_count=10,
)

config = speech.RecognitionConfig(
    encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16,
    sample_rate_hertz=8000,
    language_code="en-US",
    diarization_config=diarization_config,
)

print("Waiting for operation to complete...")
response = client.recognize(config=config, audio=audio)

# The transcript within each result is separate and sequential per result.
# However, the words list within an alternative includes all the words
# from all the results thus far. Thus, to get all the words with speaker
# tags, you only have to take the words list from the last result:
result = response.results[-1]

words_info = result.alternatives[0].words

# Printing out the output:
for word_info in words_info:
    print(f"word: '{word_info.word}', speaker_tag: {word_info.speaker_tag}")

return result