Como adicionar metadados de reconhecimento

Esta página descreve como adicionar mais detalhes sobre o áudio de origem incluído em uma solicitação de reconhecimento de fala para a Speech-to-Text.

A Speech-to-Text tem vários modelos de machine learning a serem usados para converter áudio gravado em texto. Cada um desses modelos foi treinado com base em características específicas da entrada de áudio, incluindo o tipo de arquivo de áudio, o dispositivo de gravação original, a distância entre o interlocutor e o dispositivo de gravação, o número de interlocutores no arquivo de áudio e outros fatores.

Quando você envia uma solicitação de transcrição ao Speech-to-Text, é possível incluir outros detalhes sobre os dados de áudio como metadados de reconhecimento. O Speech-to-Text pode usar esses detalhes para transcrever com mais precisão os dados de áudio.

O Google também analisa e agrega os casos de uso mais comuns do Speech-to-Text, coletando esses metadados. Assim, é possível priorizar os casos de uso mais relevantes para aprimorar o Speech-to-Text.

Campos de metadados disponíveis

Você pode fornecer qualquer um dos campos da lista a seguir nos metadados de uma solicitação de transcrição.

Campo Tipo Descrição
interactionType ENUM O caso de uso do áudio.
industryNaicsCodeOfAudio número O setor vertical do arquivo de áudio, como um código NAICS de seis dígitos.
microphoneDistance ENUM A distância entre o microfone e o interlocutor.
originalMediaType ENUM A mídia original do áudio ou vídeo.
recordingDeviceType ENUM O tipo de dispositivo usado para capturar o áudio, incluindo smartphones, microfones de PC, veículos etc.
recordingDeviceName string Dispositivo usado para fazer a gravação. Essa string arbitrária pode incluir nomes como "Pixel XL", "VoIP", "Microfone Cardioide" ou outro valor.
originalMimeType string O tipo MIME do arquivo de áudio original. Os exemplos incluem audio/m4a, audio/x-alaw-basic, audio/mp3, audio/3gpp ou outro tipo MIME de arquivo de áudio.
obfuscatedId string O código protegido por privacidade do usuário, para identificar o número de usuários únicos que usam o serviço.
audioTopic string Uma descrição arbitrária do assunto discutido no arquivo de áudio. Os exemplos incluem "visita guiada à cidade de Nova York", "audiência de julgamento" ou "entrevista ao vivo entre duas pessoas".

Consulte a documentação de referência RecognitionMetadata para mais informações sobre esses campos.

Usar metadados de reconhecimento

Para adicionar metadados de reconhecimento a uma solicitação de reconhecimento de fala para a API Speech-to-Text, defina o campo metadata da solicitação de reconhecimento de fala como um objeto RecognitionMetadata. A API Speech-to-Text é compatível com todos os métodos de reconhecimento de fala: speech:recognize speech:longrunningrecognize e Streaming. Consulte a documentação de referência RecognitionMetadata para mais informações sobre os tipos de metadados que é possível incluir em sua solicitação.

O código a seguir demonstra como especificar mais campos de metadados em uma solicitação de transcrição.

Protocolo

Consulte o endpoint da API speech:recognize para ver todos os detalhes.

Para executar o reconhecimento de fala síncrono, faça uma solicitação POST e forneça o corpo apropriado a ela. Veja a seguir um exemplo de uma solicitação POST usando curl. Nele, é usado o token de acesso de uma conta de serviço configurada para o projeto usando o SDK do Cloud do Google Cloud. Consulte o guia de início rápido para ver instruções de como instalar o SDK do Cloud, configurar um projeto com uma conta de serviço e conseguir um token de acesso.

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

Consulte a documentação de referência RecognitionConfig para mais informações sobre como configurar o corpo da solicitação.

Quando a solicitação é bem-sucedida, o servidor retorna um código de status HTTP 200 OK e a resposta no formato JSON:

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

Java

Ver no GitHub (em inglês) Feedback
/*
 * 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

Ver no GitHub (em inglês) Feedback
// 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 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.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(request={"config": config, "audio": audio})

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