Transkriptionsgenauigkeit durch optimierte Sprachanpassung verbessern

Hinweise

Die optimierte Sprachanpassung ist ein optionales Feature der Sprachanpassung. Sehen Sie sich unbedingt die Dokumentation zur Sprachanpassung an, bevor Sie die optimierte Sprachanpassung implementieren. Auf der Seite zur Sprachunterstützung können Sie sehen, ob das Optimierungsfeature für Ihre Sprache verfügbar ist.

Übersicht

Standardmäßig hat die Sprachanpassung einen relativ kleinen Effekt, insbesondere bei Wortgruppen mit nur einem Wort. Bei der optimierten Sprachanpassung können Sie die Gewichtung bestimmter Wörter durch das Erkennungsmodell anpassen. Angenommen, es gibt viele Aufnahmen von Personen, die nach "fare to get into the county fair" (Fahrpreis für die Fahrt zum Jahrmarkt) fragen, wobei das Wort "fair" häufiger vorkommt als "fare". In diesem Fall soll Speech-to-Text häufiger "fair" und "fare" erkennen als beispielsweise "hare" oder "lair". Gleichzeitig soll häufiger "fair" als "fare" erkannt werden, da dieses Wort in den Audiodaten öfter vorkommt.

In diesem Fall sollten Sie die Gewichtung sowohl von "fair" als auch von "fare" erhöhen, um die Wahrscheinlichkeit zu steigern, dass diese Wörter richtig erkannt werden. Da "fair" jedoch häufiger als "fare" vorkommt, können Sie "fair" noch höher gewichteten, um die Speech-to-Text API zu veranlassen, dieses Wort häufiger als "fare" auszuwählen.

Verstärkerwerte festlegen

Wenn Sie die Optimierung verwenden, weisen Sie einem SpeechContext-Objekt einen Gewichtungswert zu. Speech-to-Text berücksichtigt diesen Gewichtungswert, wenn es eine mögliche Transkription für Wörter in Audiodaten auswählt. Je höher der Wert, desto höher die Wahrscheinlichkeit, dass Speech-to-Text diese Wortgruppe aus den möglichen Alternativen auswählt.

Durch höhere Optimierungswerte lässt sich die Zahl der falsch-negativen Ergebnisse möglicherweise verringern. Solche Ergebnisse liegen vor, wenn ein Wort oder eine Wortgruppe in den Audiodaten vorkommt, aber von Speech-to-Text nicht richtig erkannt wird. Durch die Optimierung kann aber auch die Wahrscheinlichkeit von falsch-positiven Ergebnissen erhöht werden. Das sind Ergebnisse, bei denen das Wort oder die Wortgruppe in der Transkription vorkommt, obwohl es nicht in den Audiodaten enthalten ist.

Optimierungswerte müssen einen Gleitkommawert größer als 0 haben. Die praktische Obergrenze für Optimierungswerte beträgt 20. Um optimale Ergebnisse zu erzielen, sollten Sie mit den Transkriptionsergebnissen experimentieren, indem Sie einen anfänglichen Optimierungswert wählen und diesen dann erhöhen oder verringern.

Beispiel für die optimierte Sprachanpassung

Wenn Sie in Ihrer Sprachtranskriptionsanfrage verschiedene Optimierungswerte für "fair" und "fare" einstellen möchten, legen Sie im speechContexts-Array des RecognitionConfig-Objekts zwei SpeechContext-Objekte fest. Setzen Sie für jedes SpeechContext-Objekt einen boost-Wert auf einen nicht negativen Gleitkommawert, wobei ein Objekt "fair" und der andere "fare" enthält.

Das folgende Snippet zeigt ein Beispiel für eine JSON-Nutzlast, die an die Speech-to-Text API gesendet wird. Das JSON-Snippet enthält ein RecognitionConfig-Objekt, in dem Optimierungswerte verwendet werden, um die Wörter "fair" und "fare" unterschiedlich zu gewichten.

"config": {
    "encoding":"LINEAR16",
    "sampleRateHertz": 8000,
    "languageCode":"en-US",
    "speechContexts": [{
      "phrases": ["fair"],
      "boost": 15
     }, {
      "phrases": ["fare"],
      "boost": 2
     }]
  }

Im folgenden Codebeispiel wird gezeigt, wie Sie eine Anfrage mit optimierter Sprachanpassung senden.

REST & CMD LINE

Weitere Informationen zum API-Endpunkt finden Sie unter speech:recognize.

Ersetzen Sie diese Werte in den folgenden Anweisungen:

  • language-code: Der BCP-47-Code der Sprache, die in Ihrem Audioclip gesprochen wird.
  • phrases-to-boost: Wortgruppe(n), die von Speech-to-Text optimiert werden sollen, als Array von Strings.
  • storage-bucket: Ein Cloud Storage-Bucket.
  • input-audio: Die zu transkribierenden Audiodaten.

HTTP-Methode und URL:

POST https://speech.googleapis.com/v1p1beta1/speech:recognize

JSON-Text anfordern:

{
  "config":{
      "languageCode":"language-code",
      "speechContexts":[{
          "phrases":[phrases-to-boost],
          "boost": 2
      }]
  },
  "audio":{
    "uri":"gs:storage-bucket/input-file"
  }
}

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten in etwa folgende JSON-Antwort erhalten:

{
  "results": [
    {
      "alternatives": [
        {
          "transcript": "When deciding whether to bring an umbrella, I consider the weather",
          "confidence": 0.9463943
        }
      ],
      "languageCode": "en-us"
    }
  ]
}

Java

import com.google.cloud.speech.v1p1beta1.RecognitionAudio;
import com.google.cloud.speech.v1p1beta1.RecognitionConfig;
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.SpeechContext;
import com.google.cloud.speech.v1p1beta1.SpeechRecognitionAlternative;
import com.google.cloud.speech.v1p1beta1.SpeechRecognitionResult;
import java.io.IOException;

public class SpeechAdaptation {

  public void speechAdaptation() throws IOException {
    String uriPath = "gs://cloud-samples-data/speech/brooklyn_bridge.mp3";
    speechAdaptation(uriPath);
  }

  public static void speechAdaptation(String uriPath) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (SpeechClient speechClient = SpeechClient.create()) {

      // Provides "hints" to the speech recognizer to favor specific words and phrases in the
      // results.
      // https://cloud.google.com/speech-to-text/docs/reference/rpc/google.cloud.speech.v1p1beta1#google.cloud.speech.v1p1beta1.SpeechContext
      SpeechContext speechContext =
          SpeechContext.newBuilder().addPhrases("Brooklyn Bridge").setBoost(20.0F).build();
      // Configure recognition config to match your audio file.
      RecognitionConfig config =
          RecognitionConfig.newBuilder()
              .setEncoding(RecognitionConfig.AudioEncoding.MP3)
              .setSampleRateHertz(44100)
              .setLanguageCode("en-US")
              .addSpeechContexts(speechContext)
              .build();
      // Set the path to your audio file
      RecognitionAudio audio = RecognitionAudio.newBuilder().setUri(uriPath).build();

      // Make the request
      RecognizeRequest request =
          RecognizeRequest.newBuilder().setConfig(config).setAudio(audio).build();

      // Display the results
      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());
      }
    }
  }
}

Node.js


const speech = require('@google-cloud/speech').v1p1beta1;

/**
 * Performs synchronous speech recognition with speech adaptation.
 *
 * @param sampleRateHertz {number} Sample rate in Hertz of the audio data sent in all
 * `RecognitionAudio` messages. Valid values are: 8000-48000.
 * @param languageCode {string} The language of the supplied audio.
 * @param phrase {string} Phrase "hints" help Speech-to-Text API recognize the specified phrases from
 * your audio data.
 * @param boost {number} Positive value will increase the probability that a specific phrase will be
 * recognized over other similar sounding phrases.
 * @param uriPath {string} Path to the audio file stored on GCS.
 */
function sampleRecognize(
  sampleRateHertz,
  languageCode,
  phrase,
  boost,
  uriPath
) {
  const client = new speech.SpeechClient();
  // const sampleRateHertz = 44100;
  // const languageCode = 'en-US';
  // const phrase = 'Brooklyn Bridge';
  // const boost = 20.0;
  // const uriPath = 'gs://cloud-samples-data/speech/brooklyn_bridge.mp3';
  const encoding = 'MP3';
  const phrases = [phrase];
  const speechContextsElement = {
    phrases: phrases,
    boost: boost,
  };
  const speechContexts = [speechContextsElement];
  const config = {
    encoding: encoding,
    sampleRateHertz: sampleRateHertz,
    languageCode: languageCode,
    speechContexts: speechContexts,
  };
  const audio = {
    uri: uriPath,
  };
  const request = {
    config: config,
    audio: audio,
  };
  client
    .recognize(request)
    .then(responses => {
      const response = responses[0];
      for (const result of response.results) {
        // First alternative is the most probable result
        const alternative = result.alternatives[0];
        console.log(`Transcript: ${alternative.transcript}`);
      }
    })
    .catch(err => {
      console.error(err);
    });
}

Python

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

def sample_recognize(storage_uri, phrase):
    """
    Transcribe a short audio file with speech adaptation.

    Args:
      storage_uri URI for audio file in Cloud Storage, e.g. gs://[BUCKET]/[FILE]
      phrase Phrase "hints" help recognize the specified phrases from your audio.
    """

    client = speech_v1p1beta1.SpeechClient()

    # storage_uri = 'gs://cloud-samples-data/speech/brooklyn_bridge.mp3'
    # phrase = 'Brooklyn Bridge'
    phrases = [phrase]

    # Hint Boost. This value increases the probability that a specific
    # phrase will be recognized over other similar sounding phrases.
    # The higher the boost, the higher the chance of false positive
    # recognition as well. Can accept wide range of positive values.
    # Most use cases are best served with values between 0 and 20.
    # Using a binary search happroach may help you find the optimal value.
    boost = 20.0
    speech_contexts_element = {"phrases": phrases, "boost": boost}
    speech_contexts = [speech_contexts_element]

    # Sample rate in Hertz of the audio data sent
    sample_rate_hertz = 44100

    # The language of the supplied audio
    language_code = "en-US"

    # Encoding of audio data sent. This sample sets this explicitly.
    # This field is optional for FLAC and WAV audio formats.
    encoding = enums.RecognitionConfig.AudioEncoding.MP3
    config = {
        "speech_contexts": speech_contexts,
        "sample_rate_hertz": sample_rate_hertz,
        "language_code": language_code,
        "encoding": encoding,
    }
    audio = {"uri": storage_uri}

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

Nächste Schritte