Lange Audiodateien transkribieren

Auf dieser Seite wird gezeigt, wie lange Audiodateien (länger als eine Minute) mithilfe asynchroner Spracherkennung in Text transkribiert werden.

Bei der asynchronen Spracherkennung wird ein längerer Vorgang zur Audioverarbeitung gestartet. Verwenden Sie die asynchrone Spracherkennung, um Audios zu transkribieren, die länger als 60 Sekunden sind. Für kürzere Audiodaten ist die synchrone Spracherkennung schneller und einfacher.

Audioinhalte können von einer lokalen Datei zur asynchronen Verarbeitung direkt an Speech-to-Text gesendet werden. Das Audiozeitlimit für lokale Dateien beträgt jedoch 60 Sekunden. Der Versuch, lokale Audiodateien zu transkribieren, die länger als 60 Sekunden sind, führt zu einem Fehler. Wenn Sie die asynchrone Spracherkennung verwenden möchten, um Audios zu transkribieren, die länger als 60 Sekunden sind, müssen Sie Ihre Daten in einem Google Cloud Storage-Bucket speichern.

Sie können die Ergebnisse des Vorgangs mit der Methode google.longrunning.Operations abrufen. Die Ergebnisse können fünf Tage (120 Stunden) abgerufen werden. Sie haben auch die Möglichkeit, Ihre Ergebnisse direkt in einen Google Cloud Storage-Bucket hochzuladen.

Lange Audiodateien mithilfe einer Google Cloud Storage-Datei transkribieren

Bei diesen Beispielen wird ein Cloud Storage-Bucket verwendet, um die eingehenden Audio-Rohdaten für den Transkriptionsprozess mit langer Ausführungszeit zu speichern. Ein Beispiel für eine typische longrunningrecognize-Vorgangsantwort finden Sie in der Referenzdokumentation.

Protokoll

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

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': {
    'language_code': 'en-US'
  },
  'audio':{
    'uri':'gs://gcs-test-data/vr.flac'
  }
}" "https://speech.googleapis.com/v1/speech:longrunningrecognize"

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

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

{
  "name": "7612202767953098924"
}

Dabei ist name der Name des lang andauernden Vorgangs, der für die Anfrage erstellt wurde.

Warten Sie, bis die Verarbeitung abgeschlossen ist. Die Verarbeitungszeit hängt vom Quell-Audio ab. In den meisten Fällen erhalten Sie Ergebnisse in der Hälfte der Zeit, die das Quell-Audio lang ist. Sie können den Status Ihres lang andauernden Vorgangs abrufen. Stellen Sie dazu eine GET-Anfrage an den Endpunkt https://speech.googleapis.com/v1/operations/. Ersetzen Sie your-operation-name durch den name, der von Ihrer longrunningrecognize-Anfrage zurückgegeben wurde.

curl -H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
     -H "Content-Type: application/json; charset=utf-8" \
     "https://speech.googleapis.com/v1/operations/your-operation-name"

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

{
  "name": "7612202767953098924",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.speech.v1.LongRunningRecognizeMetadata",
    "progressPercent": 100,
    "startTime": "2017-07-20T16:36:55.033650Z",
    "lastUpdateTime": "2017-07-20T16:37:17.158630Z"
  },
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.cloud.speech.v1.LongRunningRecognizeResponse",
    "results": [
      {
        "alternatives": [
          {
            "transcript": "okay so what am I doing here...(etc)...",
            "confidence": 0.96096134,
          }
        ]
      },
      {
        "alternatives": [
          {
            ...
          }
        ]
      }
    ]
  }
}

Wenn der Vorgang nicht abgeschlossen ist, können Sie den Endpunkt abfragen. Dazu stellen Sie wiederholt eine GET-Anfrage, bis das Attribut done der Antwort true ist.

gcloud

Ausführliche Informationen finden Sie unter dem Befehl recognize-long-running.

Verwenden Sie zum Ausführen der asynchronen Spracherkennung das gcloud-Befehlszeilentool und geben Sie den Pfad einer lokalen Datei oder einer Google Cloud Storage-URL an.

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

Wenn die Anfrage erfolgreich ist, gibt der Server die ID des lang laufenden Vorgangs im JSON-Format zurück.

{
  "name": OPERATION_ID
}

Sie können dann mit dem folgenden Befehl Informationen zum Vorgang abrufen:

gcloud ml speech operations describe OPERATION_ID

Außerdem können Sie den Vorgang mit dem folgenden Befehl so lange abfragen, bis er abgeschlossen ist:

gcloud ml speech operations wait OPERATION_ID

Nach Abschluss des Vorgangs gibt der Vorgang ein Transkript der Audiodaten im JSON-Format zurück.

{
  "@type": "type.googleapis.com/google.cloud.speech.v1.LongRunningRecognizeResponse",
  "results": [
    {
      "alternatives": [
        {
          "confidence": 0.9840146,
          "transcript": "how old is the Brooklyn Bridge"
        }
      ]
    }
  ]
}

Go


func sendGCS(w io.Writer, client *speech.Client, gcsURI string) error {
	ctx := context.Background()

	// Send the contents of the audio file with the encoding and
	// and sample rate information to be transcripted.
	req := &speechpb.LongRunningRecognizeRequest{
		Config: &speechpb.RecognitionConfig{
			Encoding:        speechpb.RecognitionConfig_LINEAR16,
			SampleRateHertz: 16000,
			LanguageCode:    "en-US",
		},
		Audio: &speechpb.RecognitionAudio{
			AudioSource: &speechpb.RecognitionAudio_Uri{Uri: gcsURI},
		},
	}

	op, err := client.LongRunningRecognize(ctx, req)
	if err != nil {
		return err
	}
	resp, err := op.Wait(ctx)
	if err != nil {
		return err
	}

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

/**
 * Performs non-blocking speech recognition on remote FLAC file and prints the transcription.
 *
 * @param gcsUri the path to the remote LINEAR16 audio file to transcribe.
 */
public static void asyncRecognizeGcs(String gcsUri) throws Exception {
  // Configure polling algorithm
  SpeechSettings.Builder speechSettings = SpeechSettings.newBuilder();
  TimedRetryAlgorithm timedRetryAlgorithm =
      OperationTimedPollAlgorithm.create(
          RetrySettings.newBuilder()
              .setInitialRetryDelay(Duration.ofMillis(500L))
              .setRetryDelayMultiplier(1.5)
              .setMaxRetryDelay(Duration.ofMillis(5000L))
              .setInitialRpcTimeout(Duration.ZERO) // ignored
              .setRpcTimeoutMultiplier(1.0) // ignored
              .setMaxRpcTimeout(Duration.ZERO) // ignored
              .setTotalTimeout(Duration.ofHours(24L)) // set polling timeout to 24 hours
              .build());
  speechSettings.longRunningRecognizeOperationSettings().setPollingAlgorithm(timedRetryAlgorithm);

  // Instantiates a client with GOOGLE_APPLICATION_CREDENTIALS
  try (SpeechClient speech = SpeechClient.create(speechSettings.build())) {

    // Configure remote file request for FLAC
    RecognitionConfig config =
        RecognitionConfig.newBuilder()
            .setEncoding(AudioEncoding.FLAC)
            .setLanguageCode("en-US")
            .setSampleRateHertz(16000)
            .build();
    RecognitionAudio audio = RecognitionAudio.newBuilder().setUri(gcsUri).build();

    // Use non-blocking call for getting file transcription
    OperationFuture<LongRunningRecognizeResponse, LongRunningRecognizeMetadata> response =
        speech.longRunningRecognizeAsync(config, audio);
    while (!response.isDone()) {
      System.out.println("Waiting for response...");
      Thread.sleep(10000);
    }

    List<SpeechRecognitionResult> results = response.get().getResultsList();

    for (SpeechRecognitionResult result : results) {
      // There can be several alternative transcripts for a given chunk of speech. Just use the
      // first (most likely) one here.
      SpeechRecognitionAlternative alternative = result.getAlternativesList().get(0);
      System.out.printf("Transcription: %s\n", alternative.getTranscript());
    }
  }
}

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. This creates a recognition job that you
// can wait for now, or get its result later.
const [operation] = await client.longRunningRecognize(request);
// Get a Promise representation of the final result of the job
const [response] = await operation.promise();
const transcription = response.results
  .map(result => result.alternatives[0].transcript)
  .join('\n');
console.log(`Transcription: ${transcription}`);

Python

def transcribe_gcs(gcs_uri):
    """Asynchronously transcribes the audio file specified by the gcs_uri."""
    from google.cloud import speech

    client = speech.SpeechClient()

    audio = speech.RecognitionAudio(uri=gcs_uri)
    config = speech.RecognitionConfig(
        encoding=speech.RecognitionConfig.AudioEncoding.FLAC,
        sample_rate_hertz=16000,
        language_code="en-US",
    )

    operation = client.long_running_recognize(config=config, audio=audio)

    print("Waiting for operation to complete...")
    response = operation.result(timeout=90)

    # Each result is for a consecutive portion of the audio. Iterate through
    # them to get the transcripts for the entire audio file.
    for result in response.results:
        # The first alternative is the most likely one for this portion.
        print(u"Transcript: {}".format(result.alternatives[0].transcript))
        print("Confidence: {}".format(result.alternatives[0].confidence))

Weitere Sprachen

C# : Folgen Sie der Anleitung zur Einrichtung von C# auf der Seite "Clientbibliotheken" und rufen Sie dann die Speech-to-Text-Referenzdokumentation für .NET auf.

PHP: Folgen Sie der Anleitung zur Einrichtung von PHP auf der Seite "Clientbibliotheken" und rufen Sie dann die Speech-to-Text-Referenzdokumentation für PHP auf.

Ruby: Folgen Sie der Anleitung zur Einrichtung von Ruby auf der Seite "Clientbibliotheken" und rufen Sie dann die Speech-to-Text-Referenzdokumentation für Ruby auf.

Transkriptionsergebnisse in einen Cloud Storage-Bucket hochladen

Speech-to-Text unterstützt das Hochladen von lang andauernden Erkennungsergebnissen direkt in einen Cloud Storage-Bucket. Wenn Sie dieses Feature mit Cloud Storage-Triggern implementieren, können Cloud Storage-Uploads Benachrichtigungen auslösen, die Cloud Functions aufrufen, sodass Speech-to-Text nicht mehr für Erkennungsergebnisse abgefragt werden muss.

Wenn Sie möchten, dass die Ergebnisse in einen Cloud Storage-Bucket hochgeladen werden, geben Sie in Ihrer Erkennungsanfrage mit langer Ausführungszeit die optionale Ausgabekonfiguration TranscriptOutputConfig an.

  message TranscriptOutputConfig {

    oneof output_type {
      // Specifies a Cloud Storage URI for the recognition results. Must be
      // specified in the format: `gs://bucket_name/object_name`
      string gcs_uri = 1;
    }
  }

Protokoll

Ausführliche Informationen finden Sie unter dem API-Endpunkt longrunningrecognize.

Im folgenden Beispiel wird gezeigt, wie eine POST-Anforderung mit curl gesendet wird, wobei im Text der Anforderung der Pfad zu einem Cloud Storage-Bucket angegeben wird. Die Ergebnisse werden als JSON-Datei in diesen Speicherort hochgeladen, in dem SpeechRecognitionResult gespeichert ist.

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     --data "{
  'config': {...},
  'output_config': {
     'gcs_uri':'gs://bucket/result-output-path.json'
  },
  'audio': {
    'uri': 'gs://bucket/audio-path'
  }
}" "https://speech.googleapis.com/v1p1beta1/speech:longrunningrecognize"

Das LongRunningRecognizeResponse enthält den Pfad zum Cloud Storage-Bucket, in dem der Upload versucht wurde. Wenn der Upload fehlschlägt, wird ein Ausgabefehler zurückgegeben. Wenn bereits eine Datei mit demselben Namen vorhanden ist, schreibt der Upload die Ergebnisse in eine neue Datei mit einem Zeitstempel als Suffix.

{
  ...
  "metadata": {
    ...
    "outputConfig": {...}
  },
  ...
  "response": {
    ...
    "results": [...],
    "outputConfig": {
      "gcs_uri":"gs://bucket/result-output-path"
    },
    "outputError": {...}
  }
}

Jetzt testen

Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie einfach ein Konto, um die Leistungsfähigkeit von Speech-to-Text in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

Speech-to-Text kostenlos testen