Agrega metadatos de reconocimiento

En esta página, se describe cómo agregar detalles adicionales sobre el audio de origen incluido en una solicitud de reconocimiento de voz a Speech-to-Text.

Speech-to-Text tiene varios modelos de aprendizaje automático para convertir un audio grabado en texto. Cada uno de estos modelos se ha entrenado en función de las características específicas de la entrada de audio, que incluyen el tipo de archivo de audio, el dispositivo de grabación original, la distancia del interlocutor al dispositivo de grabación y el número de interlocutores en el archivo de audio, entre otros factores.

Cuando envías una solicitud de transcripción a Speech-to-Text, puedes incluir estos detalles adicionales sobre los datos de audio como metadatos de reconocimiento que envías. En Speech-to-Text, se pueden usar estos detalles para transcribir con mayor exactitud tus datos de audio.

En Google, también se analizan y agregan los casos prácticos más comunes de Speech-to-Text mediante la recopilación de estos metadatos. Así, en Google, se puede dar prioridad a los casos prácticos más importantes para mejorar Speech-to-Text.

Campos de metadatos disponibles

Puedes proporcionar cualquiera de los campos de la siguiente lista en los metadatos de una solicitud de transcripción.

Campo Tipo Descripción
interactionType ENUM Caso práctico del audio.
industryNaicsCodeOfAudio número Mercado vertical del archivo de audio, como un código NAICS de 6 dígitos.
microphoneDistance ENUM Distancia del micrófono al interlocutor.
originalMediaType ENUM Medio original del audio, ya sea audio o video.
recordingDeviceType ENUM Tipo de dispositivo usado para capturar el audio, incluidos smartphones, micrófonos de computadora de escritorio, vehículos, etcétera.
recordingDeviceName string Dispositivo usado para hacer la grabación. Esta string arbitraria puede incluir nombres como “Píxel XL”, “VoIP”, “Micrófono cardioide”, etcétera.
originalMimeType string Tipo MIME del archivo de audio original. Por ejemplo, audio/m4a, audio/x-alaw-basic, audio/mp3 y audio/3gpp, entre otros tipos de MIME de archivo de audio.
obfuscatedId string Protección de la privacidad del ID del usuario, para identificar el número de usuarios únicos que usan el servicio.
audioTopic string Descripción arbitraria de la cuestión analizada en el archivo de audio. Por ejemplo, “Visita guiada de la ciudad de Nueva York”, “audiencia en tribunal de primera instancia”, o “entrevista en vivo entre 2 personas”.

Consulta la documentación de referencia de RecognitionMetadata para obtener más información sobre estos campos.

Usa metadatos de reconocimiento

Para agregar metadatos de reconocimiento a una solicitud de reconocimiento de voz a la API de Speech-to-Text, configura el campo metadata de la solicitud de reconocimiento de voz en un objeto RecognitionMetadata. La API de Speech-to-Text admite metadatos de reconocimiento para todos los métodos de reconocimiento de voz: speech:recognize speech:longrunningrecognize y Transmisión continua. Consulta la documentación de referencia de RecognitionMetadata para obtener más información sobre los tipos de metadatos que puedes incluir en tu solicitud.

El siguiente código demuestra cómo especificar campos de metadatos adicionales en una solicitud de transcripción.

Protocolo

Consulta el extremo de la API de speech:recognize para obtener más detalles.

Para realizar un reconocimiento de voz síncrono, haz una solicitud POST y proporciona el cuerpo de la solicitud apropiado. A continuación, se muestra un ejemplo de una solicitud POST con curl. En el ejemplo, se usa el token de acceso correspondiente a la configuración de una cuenta de servicio para el proyecto con el SDK de Cloud de Google Cloud. Si deseas obtener instrucciones para instalar el SDK de Cloud, configurar un proyecto con una cuenta de servicio y conseguir un token de acceso, consulta la guía de inicio rápido.

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

Consulta la documentación de referencia de RecognitionConfig para obtener más información sobre la configuración del cuerpo de la solicitud.

Si la solicitud se completa de forma correcta, el servidor muestra un código de estado HTTP 200 OK y la respuesta en formato 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))