Différencier les locuteurs dans un enregistrement audio

Cette page explique comment attribuer des libellés aux différents locuteurs dans les données audio transcrites par Speech-to-Text.

Parfois, les données audio contiennent des passages où plusieurs locuteurs parlent. Par exemple, un fichier audio provenant d'un appel téléphonique comprend généralement les voix de deux personnes ou plus. Dans l'idéal, une transcription de l'appel inclut les locuteurs qui parlent et le moment où ils le font.

Identification du locuteur

Speech-to-Text peut reconnaître plusieurs locuteurs dans un même extrait audio. Lorsque vous envoyez une requête de transcription audio à Speech-to-Text, vous pouvez inclure un paramètre lui indiquant d'identifier les différents locuteurs de l'échantillon audio. Cette fonctionnalité, appelée identification du locuteur, permet de détecter le changement d'intervenant et attribue un numéro à chaque voix détectée dans le fichier audio.

Lorsque vous activez cette fonctionnalité dans votre requête de transcription, Speech-to-Text tente de distinguer les différentes voix incluses dans l'échantillon audio. Dans le résultat de la transcription, un libellé est attribué à chaque mot. Ce libellé contient un numéro correspondant à chaque locuteur. Les mots prononcés par un même locuteur portent le même numéro. Un résultat de transcription peut inclure autant de numéros que de locuteurs que Speech-to-Text peut identifier de manière unique dans l'échantillon audio.

Lorsque vous utilisez la fonctionnalité d'identification du locuteur, Speech-to-Text génère un agrégat mobile de l'ensemble des résultats fournis dans la transcription. Chaque résultat comprend les mots du résultat précédent. Ainsi, le tableau words compris dans le résultat final fournit les résultats complets identifiant les locuteurs de la transcription.

Consultez la page Langues acceptées pour savoir si cette fonctionnalité est disponible pour votre langue.

Activer l'identification des locuteurs dans une requête

Pour activer l'identification des locuteurs, vous devez définir le champ diarization_config dans les paramètres RecognitionFeatures. Vous devez définir les valeurs min_speaker_count et max_speaker_count en fonction du nombre de locuteurs que vous prévoyez d'utiliser dans la transcription.

Speech-to-Text permet d'utiliser la fonctionnalité d'identification du locuteur pour toutes les méthodes de reconnaissance vocale : speech:recognize et Streaming.

Utiliser un fichier local

L'extrait de code suivant montre comment activer l'identification du locuteur dans une requête de transcription envoyée à Speech-to-Text à l'aide d'un fichier local.

Protocole

Reportez-vous au point de terminaison speech:recognize de l'API pour obtenir des informations complètes.

Pour réaliser une reconnaissance vocale synchrone, exécutez une requête POST en fournissant le corps de requête approprié. Voici un exemple de requête POST utilisant curl. L'exemple utilise Google Cloud CLI pour générer un jeton d'accès. Pour obtenir des instructions sur l'installation de gcloud CLI, consultez le guide de démarrage rapide.

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

Si la requête aboutit, le serveur renvoie un code d'état HTTP 200 OK et la réponse au format JSON, enregistrée dans un fichier nommé 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

Pour savoir comment installer et utiliser la bibliothèque cliente pour Speech-to-Text, consultez la page Bibliothèques clientes Speech-to-Text. Pour en savoir plus, consultez la documentation de référence de l'API Speech-to-Text en langage Go.

Pour vous authentifier auprès de Speech-to-Text, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.


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

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