Ajouter des métadonnées de reconnaissance

Cette page explique comment ajouter des informations supplémentaires sur le contenu audio source inclus dans une requête de reconnaissance vocale envoyée à Speech-to-Text.

Speech-to-Text convertit le contenu audio enregistré en texte à l'aide de plusieurs modèles de machine learning. Chaque modèle a été entraîné selon des caractéristiques spécifiques d'entrée audio, comme le type de fichier audio, l'appareil d'enregistrement d'origine, la distance entre le locuteur et l'appareil d'enregistrement, et le nombre de locuteurs dans le fichier audio.

Lorsque vous envoyez une requête de transcription à Speech-to-Text, vous pouvez inclure ces informations supplémentaires sur les données audio en tant que métadonnées de reconnaissance. Speech-to-Text peut alors s'appuyer sur ces informations pour transcrire plus précisément vos données audio.

Après avoir collecté ces métadonnées pour analyser et regrouper les cas d'utilisation les plus courants de Speech-to-Text, Google peut hiérarchiser les principaux cas d'utilisation afin d'améliorer Speech-to-Text.

Champs de métadonnées disponibles

Vous pouvez ajouter n'importe quel champ de la liste suivante dans les métadonnées d'une requête de transcription.

Champ Type Description
interactionType ENUM Cas d'utilisation du contenu audio.
industryNaicsCodeOfAudio nombre Marché vertical du fichier audio, sous la forme d'un code SCIAN à six chiffres.
microphoneDistance ENUM Distance entre le micro et le locuteur.
originalMediaType ENUM Contenu multimédia original du fichier audio, qu'il soit audio ou vidéo.
recordingDeviceType ENUM Type d'appareil utilisé pour enregistrer le contenu audio (smartphones, micro de PC, systèmes pour véhicule, etc.).
recordingDeviceName chaîne Appareil utilisé pour l'enregistrement. Cette chaîne arbitraire peut inclure des noms, tels que "Pixel XL", "VoIP", "Micro cardioïde" ou toute autre valeur.
originalMimeType chaîne Type MIME du fichier audio d'origine. Voici quelques exemples : audio/m4a, audio/x-alaw-basic, audio/mp3, audio/3gpp ou tout autre type MIME de fichier audio.
obfuscatedId chaîne ID de protection des données confidentielles attribué à l'utilisateur qui permet d'identifier le nombre d'utilisateurs uniques du service.
audioTopic chaîne Description arbitraire du sujet traité dans le fichier audio. Voici quelques exemples : "Visite guidée de New York", "audience au tribunal" ou "entretien en direct entre deux personnes".

Pour en savoir plus sur ces champs, consultez la documentation de référence sur RecognitionMetadata.

Utiliser des métadonnées de reconnaissance

Pour ajouter des métadonnées de reconnaissance dans une requête de reconnaissance vocale envoyée à l'API Speech-to-Text, définissez le champ metadata de la requête de reconnaissance vocale sur un objet RecognitionMetadata. L'API Speech-to-Text permet l'utilisation des métadonnées de reconnaissance avec toutes les méthodes de reconnaissance vocale, à savoir speech:recognize, speech:longrunningrecognize et Streaming. Pour en savoir plus sur les types de métadonnées que vous pouvez ajouter dans votre requête, consultez la documentation de référence sur RecognitionMetadata.

Le code suivant montre comment spécifier des champs de métadonnées supplémentaires dans une requête de transcription.

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. Cet exemple fait intervenir le jeton d'accès associé à un compte de service configuré pour le projet à l'aide du SDK Cloud de Google Cloud. Pour obtenir des instructions sur l'installation du SDK Cloud, la configuration d'un projet avec un compte de service et l'obtention d'un jeton d'accès, consultez la page Démarrage rapide. 

curl -s -H "Content-Type: application/json" \
    -H "Authorization: Bearer "$(gcloud auth print-access-token) \
    https://speech.googleapis.com//speech:recognize \
    --data '{
    "config": {
        "encoding": "FLAC",
        "sampleRateHertz": 16000,
        "languageCode": "en-US",
        "enableWordTimeOffsets":  false,
        "metadata": {
            "interactionType": "VOICE_SEARCH",
            "industryNaicsCodeOfAudio": 23810,
            "microphoneDistance": "NEARFIELD",
            "originalMediaType": "AUDIO",
            "recordingDeviceType": "OTHER_INDOOR_DEVICE",
            "recordingDeviceName": "Polycom SoundStation IP 6000",
            "originalMimeType": "audio/mp3",
            "obfuscatedId": "11235813",
            "audioTopic": "questions about landmarks in NYC"
        }
    },
    "audio": {
        "uri":"gs://cloud-samples-tests/speech/brooklyn.flac"
    }
}

Pour en savoir plus sur la configuration du corps de la requête, consultez la documentation de référence sur RecognitionConfig.

Si la requête aboutit, le serveur renvoie un code d'état HTTP 200 OK et la réponse au format JSON :

{
  "results": [
    {
      "alternatives": [
        {
          "transcript": "how old is the Brooklyn Bridge",
          "confidence": 0.98360395
        }
      ]
    }
  ]
}

Java

/*
 * Please include the following imports to run this sample.
 *
 * import com.google.cloud.speech.v1p1beta1.RecognitionAudio;
 * import com.google.cloud.speech.v1p1beta1.RecognitionConfig;
 * import com.google.cloud.speech.v1p1beta1.RecognitionMetadata;
 * import com.google.cloud.speech.v1p1beta1.RecognizeRequest;
 * import com.google.cloud.speech.v1p1beta1.RecognizeResponse;
 * import com.google.cloud.speech.v1p1beta1.SpeechClient;
 * import com.google.cloud.speech.v1p1beta1.SpeechRecognitionAlternative;
 * import com.google.cloud.speech.v1p1beta1.SpeechRecognitionResult;
 * import com.google.protobuf.ByteString;
 * import java.nio.file.Files;
 * import java.nio.file.Path;
 * import java.nio.file.Paths;
 */

public static void sampleRecognize() {
  // TODO(developer): Replace these variables before running the sample.
  String localFilePath = "resources/commercial_mono.wav";
  sampleRecognize(localFilePath);
}

/**
 * Adds additional details short audio file included in this recognition request
 *
 * @param localFilePath Path to local audio file, e.g. /path/audio.wav
 */
public static void sampleRecognize(String localFilePath) {
  try (SpeechClient speechClient = SpeechClient.create()) {

    // The use case of the audio, e.g. PHONE_CALL, DISCUSSION, PRESENTATION, et al.
    RecognitionMetadata.InteractionType interactionType =
        RecognitionMetadata.InteractionType.VOICE_SEARCH;

    // The kind of device used to capture the audio
    RecognitionMetadata.RecordingDeviceType recordingDeviceType =
        RecognitionMetadata.RecordingDeviceType.SMARTPHONE;

    // The device used to make the recording.
    // Arbitrary string, e.g. 'Pixel XL', 'VoIP', 'Cardioid Microphone', or other value.
    String recordingDeviceName = "Pixel 3";
    RecognitionMetadata metadata =
        RecognitionMetadata.newBuilder()
            .setInteractionType(interactionType)
            .setRecordingDeviceType(recordingDeviceType)
            .setRecordingDeviceName(recordingDeviceName)
            .build();

    // The language of the supplied audio. Even though additional languages are
    // provided by alternative_language_codes, a primary language is still required.
    String languageCode = "en-US";
    RecognitionConfig config =
        RecognitionConfig.newBuilder()
            .setMetadata(metadata)
            .setLanguageCode(languageCode)
            .build();
    Path path = Paths.get(localFilePath);
    byte[] data = Files.readAllBytes(path);
    ByteString content = ByteString.copyFrom(data);
    RecognitionAudio audio = RecognitionAudio.newBuilder().setContent(content).build();
    RecognizeRequest request =
        RecognizeRequest.newBuilder().setConfig(config).setAudio(audio).build();
    RecognizeResponse response = speechClient.recognize(request);
    for (SpeechRecognitionResult result : response.getResultsList()) {
      // First alternative is the most probable result
      SpeechRecognitionAlternative alternative = result.getAlternativesList().get(0);
      System.out.printf("Transcript: %s\n", alternative.getTranscript());
    }
  } catch (Exception exception) {
    System.err.println("Failed to create the client due to: " + exception);
  }
}

Node.js

// Imports the Google Cloud client library for Beta API
/**
 * TODO(developer): Update client library import to use new
 * version of API when desired features become available
 */
const speech = require('@google-cloud/speech').v1p1beta1;
const fs = require('fs');

// Creates a client
const client = new speech.SpeechClient();

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const filename = 'Local path to audio file, e.g. /path/to/audio.raw';
// const encoding = 'Encoding of the audio file, e.g. LINEAR16';
// const sampleRateHertz = 16000;
// const languageCode = 'BCP-47 language code, e.g. en-US';

const recognitionMetadata = {
  interactionType: 'DISCUSSION',
  microphoneDistance: 'NEARFIELD',
  recordingDeviceType: 'SMARTPHONE',
  recordingDeviceName: 'Pixel 2 XL',
  industryNaicsCodeOfAudio: 519190,
};

const config = {
  encoding: encoding,
  sampleRateHertz: sampleRateHertz,
  languageCode: languageCode,
  metadata: recognitionMetadata,
};

const audio = {
  content: fs.readFileSync(filename).toString('base64'),
};

const request = {
  config: config,
  audio: audio,
};

// Detects speech in the audio file
const [response] = await client.recognize(request);
response.results.forEach(result => {
  const alternative = result.alternatives[0];
  console.log(alternative.transcript);
});

Python

from google.cloud import speech_v1p1beta1
from google.cloud.speech_v1p1beta1 import enums
import io

def sample_recognize(local_file_path):
    """
    Adds additional details short audio file included in this recognition request

    Args:
      local_file_path Path to local audio file, e.g. /path/audio.wav
    """

    client = speech_v1p1beta1.SpeechClient()

    # local_file_path = 'resources/commercial_mono.wav'

    # The use case of the audio, e.g. PHONE_CALL, DISCUSSION, PRESENTATION, et al.
    interaction_type = enums.RecognitionMetadata.InteractionType.VOICE_SEARCH

    # The kind of device used to capture the audio
    recording_device_type = enums.RecognitionMetadata.RecordingDeviceType.SMARTPHONE

    # The device used to make the recording.
    # Arbitrary string, e.g. 'Pixel XL', 'VoIP', 'Cardioid Microphone', or other
    # value.
    recording_device_name = "Pixel 3"
    metadata = {
        "interaction_type": interaction_type,
        "recording_device_type": recording_device_type,
        "recording_device_name": recording_device_name,
    }

    # The language of the supplied audio. Even though additional languages are
    # provided by alternative_language_codes, a primary language is still required.
    language_code = "en-US"
    config = {"metadata": metadata, "language_code": language_code}
    with io.open(local_file_path, "rb") as f:
        content = f.read()
    audio = {"content": content}

    response = client.recognize(config, audio)
    for result in response.results:
        # First alternative is the most probable result
        alternative = result.alternatives[0]
        print(u"Transcript: {}".format(alternative.transcript))