Kurze Audiodateien transkribieren

Auf dieser Seite wird gezeigt, wie eine kurze Audiodatei mithilfe synchroner Spracherkennung in Text transkribiert wird.

Bei der synchronen Spracherkennung wird der erkannte Text für eine kurze Audiosequenz (unter einer Minute) sofort nach der Verarbeitung zurückgegeben. Zur Verarbeitung einer Spracherkennungsanfrage für lange Audios verwenden Sie die asynchrone Spracherkennung.

Audioinhalte können direkt an Speech-to-Text gesendet werden oder es können Audioinhalte verarbeitet werden, die sich bereits in Google Cloud Storage befinden. Weitere Informationen zu Anfragen für die synchrone Spracherkennung finden Sie unter Audiobeschränkungen.

Version 1 von Speech-to-Text wurde veröffentlicht und ist über den Endpunkt https://speech.googleapis.com/v1/speech allgemein verfügbar. Die Clientbibliotheken wurden als Alphaversion veröffentlicht und werden vermutlich nicht abwärtskompatibel sein. Die Clientbibliotheken werden derzeit nicht für eine Verwendung in der Produktion empfohlen.

Für diese Beispiele ist es erforderlich, dass Sie gcloud eingerichtet sowie ein Dienstkonto erstellt und aktiviert haben. Informationen zum Einrichten von gcloud sowie zum Erstellen und Aktivieren eines Dienstkontos finden Sie in der Kurzanleitung.

Synchrone Spracherkennung für eine lokale Datei ausführen

Im Folgenden finden Sie ein Beispiel für eine synchrone Spracherkennung für eine lokale Audiodatei.

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 -X POST \
         -H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
         -H "Content-Type: application/json; charset=utf-8" \
         --data "{
      'config': {
        'encoding': 'LINEAR16',
        'sampleRateHertz': 16000,
        'languageCode': 'en-US',
        'enableWordTimeOffsets': false
      },
      'audio': {
        'content': '/9j/7QBEUGhvdG9zaG9...base64-encoded-audio-content...fXNWzvDEeYxxxzj/Coa6Bax//Z'
      }
    }" "https://speech.googleapis.com/v1/speech:recognize"
      

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

Der im Anfragetext bereitgestellte Audioinhalt ist base64-codiert. Weitere Informationen zur base64-Codierung erhalten Sie unter base64-Codierung von Audioinhalten. Weitere Informationen zum Feld content finden Sie unter RecognitionAudio.

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.98267895
            }
          ]
        }
      ]
    }
    

gcloud-Befehl

Ausführliche Informationen finden Sie unter dem Befehl recognize.

Verwenden Sie zur Spracherkennung in einer lokalen Datei das gcloud-Befehlszeilentool und übergeben Sie den lokalen Dateipfad der Datei, um die Spracherkennung durchzuführen.

    gcloud ml speech recognize PATH-TO-LOCAL-FILE --language-code='en-US'
    

Wenn die Anfrage erfolgreich ist, gibt der Server eine Antwort im JSON-Format zurück:

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

C#

static object SyncRecognize(string filePath)
    {
        var speech = SpeechClient.Create();
        var response = speech.Recognize(new RecognitionConfig()
        {
            Encoding = RecognitionConfig.Types.AudioEncoding.Linear16,
            SampleRateHertz = 16000,
            LanguageCode = "en",
        }, RecognitionAudio.FromFile(filePath));
        foreach (var result in response.Results)
        {
            foreach (var alternative in result.Alternatives)
            {
                Console.WriteLine(alternative.Transcript);
            }
        }
        return 0;
    }

Go


    func recognize(w io.Writer, file string) error {
    	ctx := context.Background()

    	client, err := speech.NewClient(ctx)
    	if err != nil {
    		return err
    	}

    	data, err := ioutil.ReadFile(file)
    	if err != nil {
    		return err
    	}

    	// Send the contents of the audio file with the encoding and
    	// and sample rate information to be transcripted.
    	resp, err := client.Recognize(ctx, &speechpb.RecognizeRequest{
    		Config: &speechpb.RecognitionConfig{
    			Encoding:        speechpb.RecognitionConfig_LINEAR16,
    			SampleRateHertz: 16000,
    			LanguageCode:    "en-US",
    		},
    		Audio: &speechpb.RecognitionAudio{
    			AudioSource: &speechpb.RecognitionAudio_Content{Content: data},
    		},
    	})

    	// Print the results.
    	for _, result := range resp.Results {
    		for _, alt := range result.Alternatives {
    			fmt.Fprintf(w, "\"%v\" (confidence=%3f)\n", alt.Transcript, alt.Confidence)
    		}
    	}
    	return nil
    }
    

Java

/*
     * Please include the following imports to run this sample.
     *
     * import com.google.cloud.speech.v1.RecognitionAudio;
     * import com.google.cloud.speech.v1.RecognitionConfig;
     * import com.google.cloud.speech.v1.RecognizeRequest;
     * import com.google.cloud.speech.v1.RecognizeResponse;
     * import com.google.cloud.speech.v1.SpeechClient;
     * import com.google.cloud.speech.v1.SpeechRecognitionAlternative;
     * import com.google.cloud.speech.v1.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/brooklyn_bridge.raw";
      sampleRecognize(localFilePath);
    }

    /**
     * Transcribe a short audio file using synchronous speech recognition
     *
     * @param localFilePath Path to local audio file, e.g. /path/audio.wav
     */
    public static void sampleRecognize(String localFilePath) {
      try (SpeechClient speechClient = SpeechClient.create()) {

        // The language of the supplied audio
        String languageCode = "en-US";

        // Sample rate in Hertz of the audio data sent
        int sampleRateHertz = 16000;

        // Encoding of audio data sent. This sample sets this explicitly.
        // This field is optional for FLAC and WAV audio formats.
        RecognitionConfig.AudioEncoding encoding = RecognitionConfig.AudioEncoding.LINEAR16;
        RecognitionConfig config =
            RecognitionConfig.newBuilder()
                .setLanguageCode(languageCode)
                .setSampleRateHertz(sampleRateHertz)
                .setEncoding(encoding)
                .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
    const fs = require('fs');
    const speech = require('@google-cloud/speech');

    // 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 config = {
      encoding: encoding,
      sampleRateHertz: sampleRateHertz,
      languageCode: languageCode,
    };
    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);
    const transcription = response.results
      .map(result => result.alternatives[0].transcript)
      .join('\n');
    console.log('Transcription: ', transcription);

PHP

use Google\Cloud\Speech\V1\SpeechClient;
    use Google\Cloud\Speech\V1\RecognitionAudio;
    use Google\Cloud\Speech\V1\RecognitionConfig;
    use Google\Cloud\Speech\V1\RecognitionConfig\AudioEncoding;

    /** Uncomment and populate these variables in your code */
    // $audioFile = 'path to an audio file';

    // change these variables if necessary
    $encoding = AudioEncoding::LINEAR16;
    $sampleRateHertz = 32000;
    $languageCode = 'en-US';

    // get contents of a file into a string
    $content = file_get_contents($audioFile);

    // set string as audio content
    $audio = (new RecognitionAudio())
        ->setContent($content);

    // set config
    $config = (new RecognitionConfig())
        ->setEncoding($encoding)
        ->setSampleRateHertz($sampleRateHertz)
        ->setLanguageCode($languageCode);

    // create the speech client
    $client = new SpeechClient();

    try {
        $response = $client->recognize($config, $audio);
        foreach ($response->getResults() as $result) {
            $alternatives = $result->getAlternatives();
            $mostLikely = $alternatives[0];
            $transcript = $mostLikely->getTranscript();
            $confidence = $mostLikely->getConfidence();
            printf('Transcript: %s' . PHP_EOL, $transcript);
            printf('Confidence: %s' . PHP_EOL, $confidence);
        }
    } finally {
        $client->close();
    }

Python

from google.cloud import speech_v1
    from google.cloud.speech_v1 import enums
    import io

    def sample_recognize(local_file_path):
        """
        Transcribe a short audio file using synchronous speech recognition

        Args:
          local_file_path Path to local audio file, e.g. /path/audio.wav
        """

        client = speech_v1.SpeechClient()

        # local_file_path = 'resources/brooklyn_bridge.raw'

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

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

        # Encoding of audio data sent. This sample sets this explicitly.
        # This field is optional for FLAC and WAV audio formats.
        encoding = enums.RecognitionConfig.AudioEncoding.LINEAR16
        config = {
            "language_code": language_code,
            "sample_rate_hertz": sample_rate_hertz,
            "encoding": encoding,
        }
        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))

    

Ruby

# audio_file_path = "Path to file on which to perform speech recognition"

    require "google/cloud/speech"

    speech = Google::Cloud::Speech.new

    audio_file = File.binread audio_file_path
    config     = { encoding:          :LINEAR16,
                   sample_rate_hertz: 16_000,
                   language_code:     "en-US" }
    audio      = { content: audio_file }

    response = speech.recognize config, audio

    results = response.results

    alternatives = results.first.alternatives
    alternatives.each do |alternative|
      puts "Transcription: #{alternative.transcript}"
    end

Synchrone Spracherkennung für eine Remote-Datei ausführen

Die Speech-to-Text API kann die synchrone Spracherkennung direkt für eine Audiodatei in Google Cloud Storage ausführen, ohne dass Sie den Inhalt der Audiodatei im Text Ihrer Anfrage senden müssen.

Hier ist ein Beispiel für die Durchführung einer synchronen Spracherkennung für eine Datei in Cloud Storage:

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 -X POST -H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
         -H "Content-Type: application/json; charset=utf-8" \
         --data "{
      'config': {
        'encoding': 'LINEAR16',
        'sampleRateHertz': 16000,
        'languageCode': 'en-US'
      },
      'audio': {
        'uri': 'gs://YOUR_BUCKET_NAME/YOUR_FILE_NAME'
      }
    }" "https://speech.googleapis.com/v1/speech:recognize"
    

Weitere Informationen zum Konfigurieren des Anfragetexts finden 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.98267895
            }
          ]
        }
      ]
    }
    

gcloud-Befehl

Ausführliche Informationen finden Sie unter dem Befehl recognize.

Verwenden Sie zur Spracherkennung in einer lokalen Datei das gcloud-Befehlszeilentool und übergeben Sie den lokalen Dateipfad der Datei, um die Spracherkennung durchzuführen.

    gcloud ml speech recognize 'gs://cloud-samples-tests/speech/brooklyn.flac' \
    --language-code='en-US'
    

Wenn die Anfrage erfolgreich ist, gibt der Server eine Antwort im JSON-Format zurück:

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

C#

static object SyncRecognizeGcs(string storageUri)
    {
        var speech = SpeechClient.Create();
        var response = speech.Recognize(new RecognitionConfig()
        {
            Encoding = RecognitionConfig.Types.AudioEncoding.Linear16,
            SampleRateHertz = 16000,
            LanguageCode = "en",
        }, RecognitionAudio.FromStorageUri(storageUri));
        foreach (var result in response.Results)
        {
            foreach (var alternative in result.Alternatives)
            {
                Console.WriteLine(alternative.Transcript);
            }
        }
        return 0;
    }

Go


    func recognizeGCS(w io.Writer, gcsURI string) error {
    	ctx := context.Background()

    	client, err := speech.NewClient(ctx)
    	if err != nil {
    		return err
    	}

    	// Send the request with the URI (gs://...)
    	// and sample rate information to be transcripted.
    	resp, err := client.Recognize(ctx, &speechpb.RecognizeRequest{
    		Config: &speechpb.RecognitionConfig{
    			Encoding:        speechpb.RecognitionConfig_LINEAR16,
    			SampleRateHertz: 16000,
    			LanguageCode:    "en-US",
    		},
    		Audio: &speechpb.RecognitionAudio{
    			AudioSource: &speechpb.RecognitionAudio_Uri{Uri: gcsURI},
    		},
    	})

    	// Print the results.
    	for _, result := range resp.Results {
    		for _, alt := range result.Alternatives {
    			fmt.Fprintf(w, "\"%v\" (confidence=%3f)\n", alt.Transcript, alt.Confidence)
    		}
    	}
    	return nil
    }
    

Java

/*
     * Please include the following imports to run this sample.
     *
     * import com.google.cloud.speech.v1.RecognitionAudio;
     * import com.google.cloud.speech.v1.RecognitionConfig;
     * import com.google.cloud.speech.v1.RecognizeRequest;
     * import com.google.cloud.speech.v1.RecognizeResponse;
     * import com.google.cloud.speech.v1.SpeechClient;
     * import com.google.cloud.speech.v1.SpeechRecognitionAlternative;
     * import com.google.cloud.speech.v1.SpeechRecognitionResult;
     */

    public static void sampleRecognize() {
      // TODO(developer): Replace these variables before running the sample.
      String storageUri = "gs://cloud-samples-data/speech/brooklyn_bridge.raw";
      sampleRecognize(storageUri);
    }

    /**
     * Transcribe short audio file from Cloud Storage using synchronous speech recognition
     *
     * @param storageUri URI for audio file in Cloud Storage, e.g. gs://[BUCKET]/[FILE]
     */
    public static void sampleRecognize(String storageUri) {
      try (SpeechClient speechClient = SpeechClient.create()) {

        // Sample rate in Hertz of the audio data sent
        int sampleRateHertz = 16000;

        // The language of the supplied audio
        String languageCode = "en-US";

        // Encoding of audio data sent. This sample sets this explicitly.
        // This field is optional for FLAC and WAV audio formats.
        RecognitionConfig.AudioEncoding encoding = RecognitionConfig.AudioEncoding.LINEAR16;
        RecognitionConfig config =
            RecognitionConfig.newBuilder()
                .setSampleRateHertz(sampleRateHertz)
                .setLanguageCode(languageCode)
                .setEncoding(encoding)
                .build();
        RecognitionAudio audio = RecognitionAudio.newBuilder().setUri(storageUri).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
    const speech = require('@google-cloud/speech');

    // Creates a client
    const client = new speech.SpeechClient();

    /**
     * TODO(developer): Uncomment the following lines before running the sample.
     */
    // const gcsUri = 'gs://my-bucket/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 config = {
      encoding: encoding,
      sampleRateHertz: sampleRateHertz,
      languageCode: languageCode,
    };
    const audio = {
      uri: gcsUri,
    };

    const request = {
      config: config,
      audio: audio,
    };

    // Detects speech in the audio file
    const [response] = await client.recognize(request);
    const transcription = response.results
      .map(result => result.alternatives[0].transcript)
      .join('\n');
    console.log('Transcription: ', transcription);

PHP

use Google\Cloud\Speech\V1\SpeechClient;
    use Google\Cloud\Speech\V1\RecognitionAudio;
    use Google\Cloud\Speech\V1\RecognitionConfig;
    use Google\Cloud\Speech\V1\RecognitionConfig\AudioEncoding;

    /** Uncomment and populate these variables in your code */
    // $uri = 'The Cloud Storage object to transcribe (gs://your-bucket-name/your-object-name)';

    // change these variables if necessary
    $encoding = AudioEncoding::LINEAR16;
    $sampleRateHertz = 32000;
    $languageCode = 'en-US';

    // set string as audio content
    $audio = (new RecognitionAudio())
        ->setUri($uri);

    // set config
    $config = (new RecognitionConfig())
        ->setEncoding($encoding)
        ->setSampleRateHertz($sampleRateHertz)
        ->setLanguageCode($languageCode);

    // create the speech client
    $client = new SpeechClient();

    try {
        $response = $client->recognize($config, $audio);
        foreach ($response->getResults() as $result) {
            $alternatives = $result->getAlternatives();
            $mostLikely = $alternatives[0];
            $transcript = $mostLikely->getTranscript();
            $confidence = $mostLikely->getConfidence();
            printf('Transcript: %s' . PHP_EOL, $transcript);
            printf('Confidence: %s' . PHP_EOL, $confidence);
        }
    } finally {
        $client->close();
    }

Python

from google.cloud import speech_v1
    from google.cloud.speech_v1 import enums

    def sample_recognize(storage_uri):
        """
        Transcribe short audio file from Cloud Storage using synchronous speech
        recognition

        Args:
          storage_uri URI for audio file in Cloud Storage, e.g. gs://[BUCKET]/[FILE]
        """

        client = speech_v1.SpeechClient()

        # storage_uri = 'gs://cloud-samples-data/speech/brooklyn_bridge.raw'

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

        # 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.LINEAR16
        config = {
            "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))

    

Ruby

# storage_path = "Path to file in Cloud Storage, eg. gs://bucket/audio.raw"

    require "google/cloud/speech"

    speech = Google::Cloud::Speech.new

    config = { encoding:          :LINEAR16,
               sample_rate_hertz: 16_000,
               language_code:     "en-US" }
    audio  = { uri: storage_path }

    response = speech.recognize config, audio

    results = response.results

    alternatives = results.first.alternatives
    alternatives.each do |alternative|
      puts "Transcription: #{alternative.transcript}"
    end