Mentranskripsikan file audio panjang menjadi teks

Halaman ini menunjukkan cara mentranskripsikan file audio yang panjang (dengan durasi lebih dari 1 menit) ke teks menggunakan Speech-to-Text API dan pengenalan ucapan asinkron.

Tentang pengenalan ucapan asinkron

Pengenalan ucapan batch memulai operasi pemrosesan audio yang berjalan lama. Gunakan pengenalan ucapan asinkron untuk mentranskripsikan audio yang berdurasi lebih dari 60 detik. Untuk audio berdurasi lebih pendek, pengenalan ucapan sinkron lebih cepat dan lebih mudah. Batas atas untuk pengenalan ucapan asinkron adalah 480 menit.

Speech-to-Text dan pemrosesan asinkron

Konten audio dapat dikirim langsung ke Speech-to-Text dari file lokal untuk pemrosesan asinkron. Namun, batas waktu audio untuk file lokal adalah 60 detik. Mentranskripsikan file audio lokal yang berdurasi lebih dari 60 detik akan menghasilkan error. Agar dapat menggunakan pengenalan ucapan asinkron untuk mentranskripsikan audio berdurasi lebih dari 60 detik, data Anda harus disimpan di bucket Google Cloud Storage.

Anda dapat mengambil hasil operasi menggunakan metode google.longrunning.Operations. Hasil akan tetap tersedia untuk diambil selama 5 hari (120 jam). Anda juga memiliki opsi untuk mengupload hasil secara langsung ke bucket Google Cloud Storage.

Mentranskripsikan file audio panjang menggunakan file Google Cloud Storage

Sampel ini menggunakan bucket Cloud Storage untuk menyimpan input audio mentah untuk proses transkripsi panjang. Untuk mengetahui contoh respons operasi longrunningrecognize standar, lihat dokumentasi referensi.

Protocol

Lihat endpoint speech:longrunningrecognize API untuk detail selengkapnya.

Untuk melakukan pengenalan ucapan sinkron, buat permintaan POST dan berikan isi permintaan yang sesuai. Berikut ini contoh permintaan POST yang menggunakan curl. Contoh ini menggunakan Google Cloud CLI untuk membuat token akses. Untuk petunjuk tentang cara menginstal gcloud CLI, lihat panduan memulai.

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://cloud-samples-tests/speech/brooklyn.flac'
  }
}" "https://speech.googleapis.com/v1/speech:longrunningrecognize"

Lihat dokumentasi referensi RecognitionConfig dan RecognitionAudio untuk mengetahui informasi selengkapnya tentang cara mengonfigurasi isi permintaan.

Jika permintaan berhasil, server akan menampilkan kode status HTTP 200 OK dan respons dalam format JSON:

{
  "name": "7612202767953098924"
}

di mana name adalah nama operasi yang berjalan lama yang dibuat untuk permintaan tersebut.

Tunggu hingga pemrosesan selesai. Waktu pemrosesan berbeda-beda, bergantung pada audio sumber Anda. Umumnya, Anda akan mendapatkan hasil dengan panjang setengah dari audio sumber. Anda bisa mendapatkan status operasi yang berjalan lama dengan membuat permintaan GET ke endpoint https://speech.googleapis.com/v1/operations/. Ganti your-operation-name dengan name yang ditampilkan dari permintaan longrunningrecognize Anda.

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"

Jika permintaan berhasil, server akan menampilkan kode status HTTP 200 OK dan respons dalam format 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": "how old is the Brooklyn Bridge",
            "confidence": 0.96096134,
          }
        ]
      },
      {
        "alternatives": [
          {
            ...
          }
        ]
      }
    ]
  }
}

Jika operasi belum selesai, Anda dapat melakukan polling endpoint dengan membuat permintaan GET berulang kali hingga properti done respons adalah true.

gcloud

Lihat perintah recognize-long-running untuk detail selengkapnya.

Untuk melakukan pengenalan ucapan asinkron, gunakan Google Cloud CLI, yang menyediakan jalur file lokal atau URL Google Cloud Storage.

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

Jika permintaan berhasil, server akan menampilkan ID operasi yang berjalan lama dalam format JSON.

{
  "name": OPERATION_ID
}

Anda kemudian bisa mendapatkan informasi tentang operasi tersebut dengan menjalankan perintah berikut.

gcloud ml speech operations describe OPERATION_ID

Anda juga dapat melakukan polling pada operasi hingga selesai dengan menjalankan perintah berikut.

gcloud ml speech operations wait OPERATION_ID

Setelah operasi selesai, operasi akan menampilkan transkrip audio dalam format JSON.

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

Go

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Speech-to-Text, lihat Library klien Speech-to-Text. Untuk mengetahui informasi selengkapnya, lihat dokumentasi referensi API Go Speech-to-Text.

Untuk mengautentikasi ke Speech-to-Text, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

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

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Speech-to-Text, lihat Library klien Speech-to-Text. Untuk mengetahui informasi selengkapnya, lihat dokumentasi referensi API Java Speech-to-Text.

Untuk mengautentikasi ke Speech-to-Text, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

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

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Speech-to-Text, lihat Library klien Speech-to-Text. Untuk mengetahui informasi selengkapnya, lihat dokumentasi referensi API Node.js Speech-to-Text.

Untuk mengautentikasi ke Speech-to-Text, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

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

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Speech-to-Text, lihat Library klien Speech-to-Text. Untuk mengetahui informasi selengkapnya, lihat dokumentasi referensi API Python Speech-to-Text.

Untuk mengautentikasi ke Speech-to-Text, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

from google.cloud import speech


def transcribe_gcs(gcs_uri: str) -> str:
    """Asynchronously transcribes the audio file from Cloud Storage
    Args:
        gcs_uri: The Google Cloud Storage path to an audio file.
            E.g., "gs://storage-bucket/file.flac".
    Returns:
        The generated transcript from the audio file provided.
    """
    client = speech.SpeechClient()

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

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

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

    transcript_builder = []
    # 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.
        transcript_builder.append(f"\nTranscript: {result.alternatives[0].transcript}")
        transcript_builder.append(f"\nConfidence: {result.alternatives[0].confidence}")

    transcript = "".join(transcript_builder)
    print(transcript)

    return transcript

Bahasa tambahan

C#: Ikuti Petunjuk penyiapan C# di halaman library klien, lalu buka Dokumentasi referensi Speech-to-Text untuk .NET.

PHP: Ikuti Petunjuk penyiapan PHP di halaman library klien, lalu buka Dokumentasi referensi Speech-to-Text untuk PHP.

Ruby: Ikuti Petunjuk penyiapan Ruby di halaman library klien, lalu buka Dokumentasi referensi Speech-to-Text untuk Ruby.

Mengupload hasil transkripsi ke bucket Cloud Storage

Speech-to-Text mendukung upload hasil pengenalan berdurasi panjang langsung ke bucket Cloud Storage. Jika Anda menerapkan fitur ini dengan Pemicu Cloud Storage, upload Cloud Storage dapat memicu notifikasi yang memanggil Cloud Functions dan menghilangkan kebutuhan melakukan polling Speech-to-Text untuk hasil pengenalan.

Agar hasil diupload ke bucket Cloud Storage, berikan konfigurasi output TranscriptOutputConfig opsional dalam permintaan pengenalan yang berjalan lama Anda.

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

Protocol

Lihat endpoint API longrunningrecognize untuk mengetahui detail selengkapnya.

Contoh berikut menunjukkan cara mengirim permintaan POST menggunakan curl, dengan isi permintaan menentukan jalur ke bucket Cloud Storage. Hasilnya diupload ke lokasi ini sebagai file JSON yang menyimpan SpeechRecognitionResult.

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"

LongRunningRecognizeResponse mencakup jalur ke bucket Cloud Storage tempat file akan diupload. Jika upload tidak berhasil, error output akan ditampilkan. Jika file dengan nama yang sama sudah ada, upload akan menulis hasilnya ke file baru dengan menambahkan stempel waktu sebagai akhiran.

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

Coba sendiri

Jika Anda baru menggunakan Google Cloud, buat akun untuk mengevaluasi performa Speech-to-Text dalam skenario dunia nyata. Pelanggan baru mendapatkan kredit gratis senilai $300 untuk menjalankan, menguji, dan men-deploy workload.

Coba Speech-to-Text gratis