Ajouter des métadonnées de reconnaissance

Aperçu

Cette fonctionnalité est couverte par les Conditions des offres avant disponibilité générale des conditions d'utilisation de Google Cloud Platform. Les fonctionnalités avant disponibilité générale sont susceptibles de présenter une compatibilité limitée, et les modifications apportées à ces fonctionnalités peuvent ne pas être compatibles avec d'autres versions avant disponibilité générale. Pour en savoir plus, consultez les descriptions des étapes de lancement.

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.

Remarque : Google ne collecte pas les données réelles du fichier audio que vous envoyez, mais seulement les métadonnées, sauf si vous avez activé la journalisation des données.

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/v1p1beta1/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

Afficher sur GitHub Commentaires

/*
 * 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

Afficher sur GitHub Commentaires

// 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();

async function syncRecognizeWithMetaData() {
  /**
   * 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

Afficher sur GitHub Commentaires

from google.cloud import speech_v1p1beta1 as speech

client = speech.SpeechClient()

speech_file = "resources/commercial_mono.wav"

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

# Here we construct a recognition metadata object.
# Most metadata fields are specified as enums that can be found
# in speech.enums.RecognitionMetadata
metadata = speech.RecognitionMetadata()
metadata.interaction_type = speech.RecognitionMetadata.InteractionType.DISCUSSION
metadata.microphone_distance = (
    speech.RecognitionMetadata.MicrophoneDistance.NEARFIELD
)
metadata.recording_device_type = (
    speech.RecognitionMetadata.RecordingDeviceType.SMARTPHONE
)

# Some metadata fields are free form strings
metadata.recording_device_name = "Pixel 2 XL"
# And some are integers, for instance the 6 digit NAICS code
# https://www.naics.com/search/
metadata.industry_naics_code_of_audio = 519190

audio = speech.RecognitionAudio(content=content)
config = speech.RecognitionConfig(
    encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16,
    sample_rate_hertz=8000,
    language_code="en-US",
    # Add this in the request to send metadata.
    metadata=metadata,
)

response = client.recognize(config=config, audio=audio)

for i, result in enumerate(response.results):
    alternative = result.alternatives[0]
    print("-" * 20)
    print(u"First alternative of result {}".format(i))
    print(u"Transcript: {}".format(alternative.transcript))