長い音声ファイルの文字変換

api Cloud Speech-to-Text API realtime_warning

このページでは、非同期音声認識を使用して、長い音声ファイル(1 分以上)をテキストに変換する方法について説明します。

非同期音声認識では、音声処理オペレーションの長時間実行が開始されます。1 分を超える長さの音声を認識するには、非同期音声認識を使用します。短い音声の場合は、同期音声認識を使用したほうが早くて簡単です。

オペレーションの結果は、google.longrunning.Operations インターフェースから取得できます。結果は 5 日後(120 時間)まで取得できます。音声コンテンツを Speech-to-Text に直接送信することも、Google Cloud Storage にすでに存在する音声コンテンツを処理することもできます。非同期音声認識リクエストについては、音声の制限もご覧ください。

Cloud Speech-to-Text v1 は正式版がリリースされ、https://speech.googleapis.com/v1/speech エンドポイントから一般提供されています。クライアント ライブラリはアルファ版としてリリースされており、下位互換性のない方法で変更される可能性があります。クライアント ライブラリの本番環境での使用は、現在推奨されていません。

これらのサンプルでは、gcloud が設定され、サービス アカウントが作成されて有効になっている必要があります。gcloud の設定、サービス アカウントの作成と有効化の方法について詳しくは、クイックスタートをご覧ください。

サンプルでは、長時間にわたる音声文字変換処理のための生の音声入力データを格納するためにCloud Storage バケットも使用しています。

プロトコル

詳細については、speech:longrunningrecognize API エンドポイントをご覧ください。

同期音声認識を実行するには、POST リクエストを作成し、適切なリクエスト本文を指定します。次は、curl を使用した POST リクエストの例です。この例では、Google Cloud の Cloud SDK を使用するプロジェクト用に設定されたサービス アカウントのアクセス トークンを使用します。Cloud SDK のインストール、サービス アカウントでのプロジェクトの設定、アクセス トークンの取得を行う手順については、クイックスタートをご覧ください。

    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"
    

リクエスト本文の構成について詳しくは、RecognitionConfigRecognitionAudio のリファレンス ドキュメントをご覧ください。

リクエストが成功すると、サーバーは 200 OK HTTP ステータス コードと JSON 形式のレスポンスを返します。

    {
      "name": "7612202767953098924"
    }
    

ここで、name はリクエストに対して作成された長時間実行オペレーションの名前です。

処理が完了するまで待ちます。処理時間はソース音声によって異なります。ほとんどの場合、ソース音声の半分の長さの結果が得られます。長時間実行オペレーションのステータスは、GET リクエストを https://speech.googleapis.com/v1/operations/ エンドポイントにすることによって取得できます。your-operation-namelongrunningrecognize リクエストから返された name に置き換えます。リクエストの進捗状況の推定は、progressPercent フィールドから取得できます。

    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"
    

リクエストが成功すると、サーバーは 200 OK HTTP ステータス コードと JSON 形式のレスポンスを返します。

    {
      "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": [
              {
                ...
              }
            ]
          }
        ]
      }
    }
    

オペレーションが完了していない場合は、レスポンスの done プロパティが true になるまで GET リクエストを繰り返し行って、エンドポイントをポーリングできます。

gcloud コマンド

詳しくは、recognize-long-running コマンドをご覧ください。

非同期音声認識を行うには、gcloud コマンドライン ツールを使用して、ローカル ファイルまたは Google Cloud Storage URL のパスを指定します。

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

リクエストが成功すると、サーバーは長時間実行オペレーションの ID を JSON 形式で返します。

    {
      "name": OPERATION_ID
    }
    

次のコマンドを実行すると、オペレーションに関する情報を取得できます。

    gcloud ml speech operations describe OPERATION_ID
    

また、次のコマンドを実行して、オペレーションが完了するまでオペレーションをポーリングすることもできます。

    gcloud ml speech operations wait OPERATION_ID
    

オペレーションが完了すると、音声が JSON 形式で返されます。

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

C#

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

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

/*
     * Please include the following imports to run this sample.
     *
     * import com.google.api.gax.longrunning.OperationFuture;
     * import com.google.cloud.speech.v1.LongRunningRecognizeMetadata;
     * import com.google.cloud.speech.v1.LongRunningRecognizeRequest;
     * import com.google.cloud.speech.v1.LongRunningRecognizeResponse;
     * import com.google.cloud.speech.v1.RecognitionAudio;
     * import com.google.cloud.speech.v1.RecognitionConfig;
     * import com.google.cloud.speech.v1.SpeechClient;
     * import com.google.cloud.speech.v1.SpeechRecognitionAlternative;
     * import com.google.cloud.speech.v1.SpeechRecognitionResult;
     */

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

    /**
     * Transcribe long audio file from Cloud Storage using asynchronous speech recognition
     *
     * @param storageUri URI for audio file in Cloud Storage, e.g. gs://[BUCKET]/[FILE]
     */
    public static void sampleLongRunningRecognize(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();
        LongRunningRecognizeRequest request =
            LongRunningRecognizeRequest.newBuilder().setConfig(config).setAudio(audio).build();
        OperationFuture<LongRunningRecognizeResponse, LongRunningRecognizeMetadata> future =
            speechClient.longRunningRecognizeAsync(request);

        System.out.println("Waiting for operation to complete...");
        LongRunningRecognizeResponse response = future.get();
        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. 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}`);

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

    // create the asyncronous recognize operation
    $operation = $client->longRunningRecognize($config, $audio);
    $operation->pollUntilComplete();

    if ($operation->operationSucceeded()) {
        $response = $operation->getResult();

        // each result is for a consecutive portion of the audio. iterate
        // through them to get the transcripts for the entire audio file.
        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);
        }
    } else {
        print_r($operation->getError());
    }

    $client->close();

Python

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

    def sample_long_running_recognize(storage_uri):
        """
        Transcribe long audio file from Cloud Storage using asynchronous 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}

        operation = client.long_running_recognize(config, audio)

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

        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 }

    operation = speech.long_running_recognize config, audio

    puts "Operation started"

    operation.wait_until_done!

    raise operation.results.message if operation.error?

    results = operation.response.results

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