Erkennungsmetadaten hinzufügen

Auf dieser Seite wird beschrieben, wie Sie zusätzliche Details über die Audioquelle hinzufügen, die in einer Spracherkennungsanfrage an Speech-to-Text enthalten ist.

In Speech-to-Text gibt es mehrere Modelle für maschinelles Lernen, mit denen aufgezeichnete Audiodaten in Text umgewandelt werden. Jedes dieser Modelle wurde basierend auf spezifischen Eigenschaften der Audioeingangsdaten trainiert, einschließlich des Typs der Audiodatei, des ursprünglichen Aufnahmegeräts, des Abstands des Sprechers vom Aufnahmegerät und der Anzahl der Sprecher in der Audiodatei.

Wenn Sie eine Transkriptionsanfrage an Speech-to-Text senden, können Sie diese zusätzlichen Details über die Audiodaten innerhalb der übermittelten Erkennungsmetadaten angeben. Mithilfe dieser Details kann Speech-to-Text Ihre Audiodaten genauer transkribieren.

Google erfasst diese Metadaten, um die gängigsten Anwendungsfälle für Speech-to-Text zu analysieren und zusammenzufassen. Dies ermöglicht Google, sich bei Verbesserungen von Speech-to-Text auf die häufigsten Anwendungsfälle zu konzentrieren.

Verfügbare Metadatenfelder

Sie können in den Metadaten einer Transkriptionsanfrage die folgenden Felder angeben.

Feld Typ Beschreibung
interactionType ENUM Der Anwendungsfall der Audiodaten.
industryNaicsCodeOfAudio Zahl Die Branche der Audiodatei als sechsstelliger NAICS-Code.
microphoneDistance ENUM Der Abstand des Mikrofons vom Sprecher.
originalMediaType ENUM Das ursprüngliche Medium des Audiomaterials, entweder reines Audio oder Video.
recordingDeviceType ENUM Die Art des für die Audioaufnahme verwendeten Geräts, einschließlich Smartphones, PC-Mikrofonen und Fahrzeugen.
recordingDeviceName String Das für die Aufzeichnung verwendete Gerät. Dieser beliebig festlegbare String kann Wörter wie "Pixel XL", "VoIP" oder "Nierenmikrofon" enthalten.
originalMimeType String Der MIME-Typ der ursprünglichen Audiodatei. Beispiele hierfür sind "audio/m4a", "audio/x-alaw-basic", "audio/mp3" und "audio/3gpp".
obfuscatedId String Die dem Datenschutz unterliegende ID des Nutzers. Diese dient dazu, die Anzahl der einzelnen Nutzer zu bestimmen, die den Dienst verwenden.
audioTopic String Eine beliebig festlegbare Beschreibung des in der Audiodatei besprochenen Themas. Beispiele sind "Führung durch New York", "Gerichtsverhandlung" oder "Liveinterview zwischen zwei Personen".

Weitere Informationen über diese Felder finden Sie in der Referenzdokumentation zu RecognitionMetadata.

Erkennungsmetadaten verwenden

Wenn Sie einer Spracherkennungsanfrage an die Speech-to-Text API Erkennungsmetadaten hinzufügen möchten, setzen Sie das Feld metadata der Anfrage auf ein Objekt vom Typ RecognitionMetadata. Die Speech-to-Text API unterstützt Erkennungsmetadaten für alle Spracherkennungsmethoden: speech:recognize, speech:longrunningrecognize und Streaming. Weitere Informationen zu den Arten von Metadaten, die Sie in einer Anfrage angeben können, finden Sie in der Referenzdokumentation zu RecognitionMetadata.

Der folgende Code zeigt, wie Sie in einer Transkriptionsanfrage zusätzliche Metadatenfelder angeben.

Protokoll

Ausführliche Informationen finden Sie unter dem API-Endpunkt speech:recognize.

Für eine synchrone Spracherkennung senden Sie eine POST-Anfrage und geben den entsprechenden Anfragetext an. Das folgende Beispiel zeigt eine POST-Anfrage mit curl. In diesem Beispiel wird das Zugriffstoken für ein Dienstkonto verwendet, das mit dem Cloud SDK von Google Cloud für das Projekt eingerichtet wurde. Anleitungen zur Installation von Cloud SDK, zur Einrichtung eines Projekts mit einem Dienstkonto und zur Anforderung eines Zugriffstokens finden Sie in der Kurzanleitung.

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

Weitere Informationen zum Konfigurieren des Anfragetexts erhalten Sie in der Referenzdokumentation zu RecognitionConfig.

Wenn die Anfrage erfolgreich ist, gibt der Server den HTTP-Statuscode 200 OK und die Antwort im JSON-Format zurück:

{
  "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))