Transcrever arquivos de áudio longos

Nesta página, veja como transcrever arquivos de áudio longos (com mais de um minuto) usando o reconhecimento de fala assíncrono.

O reconhecimento de fala assíncrono inicia uma operação de processamento de áudio de longa duração. Use o reconhecimento de fala assíncrono para transcrever áudios com mais de 60 segundos. Para áudios mais curtos, o reconhecimento de fala síncrono é mais rápido e mais simples.

O conteúdo de áudio pode ser enviado diretamente para a Speech-to-Text a partir de um arquivo local para processamento assíncrono. No entanto, o limite de tempo de áudio para arquivos locais é de 60 segundos. A tentativa de transcrever arquivos de áudio locais com mais de 60 segundos resultará em um erro. Para usar o reconhecimento de fala assíncrono para áudios com mais de 60 segundos, os dados precisam ser salvos em um bucket do Google Cloud Storage.

É possível recuperar os resultados da operação usando o método google.longrunning.Operations. Os resultados permanecem disponíveis para recuperação por 5 dias (120 horas). Você também tem a opção de fazer o upload dos resultados diretamente para um bucket do Google Cloud Storage.

Transcrição de arquivos de áudio longos usando um arquivo do Google Cloud Storage

Essas amostras usam um bucket do Cloud Storage para armazenar a entrada de áudio bruta para o processo de transcrição de longa duração. Para um exemplo de resposta de operação longrunningrecognize típica, consulte a documentação de referência.

Protocolo

Consulte o endpoint da API speech:longrunningrecognize para ver todos os detalhes.

Para executar o reconhecimento de fala síncrono, faça uma solicitação POST e forneça o corpo apropriado a ela. Veja a seguir um exemplo de uma solicitação POST usando curl. O exemplo usa o token de acesso de uma conta de serviço configurada para o projeto usando a Google Cloud CLI. Para instruções sobre como instalar a gcloud CLI, configurar um projeto com uma conta de serviço e receber um token de acesso, consulte o guia de início rápido. 

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"

Consulte as documentações de referência RecognitionConfig e RecognitionAudio para mais informações sobre como configurar o corpo da solicitação.

Quando a solicitação é bem-sucedida, o servidor retorna um código de status HTTP 200 OK e a resposta no formato JSON:

{
  "name": "7612202767953098924"
}

onde name é o nome da operação de longa execução criada para a solicitação.

Aguarde o processamento ser concluído. O tempo de processamento varia de acordo com o áudio da fonte. Na maioria dos casos, você terá resultados com metade do comprimento do áudio de origem. Você pode ver o status de sua operação de longa execução fazendo uma solicitação GET para o endpoint https://speech.googleapis.com/v1/operations/. Substitua your-operation-name pelo name retornado da sua solicitação longrunningrecognize.

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"

Quando a solicitação é bem-sucedida, o servidor retorna um código de status HTTP 200 OK e a resposta no formato 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": [
          {
            ...
          }
        ]
      }
    ]
  }
}

Se a operação não for concluída, você poderá pesquisar o endpoint repetidamente fazendo a solicitação GET até que a propriedade done da resposta seja true.

gcloud

Consulte o comando recognize-long-running para ver todos os detalhes.

Para realizar o reconhecimento de fala assíncrono, use o Google Cloud CLI, fornecendo o caminho de um arquivo local ou um URL do Google Cloud Storage.

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

Se a solicitação for bem-sucedida, o servidor retornará o código da operação de longa duração no formato JSON.

{
  "name": OPERATION_ID
}

Você poderá receber informações sobre a operação executando o comando a seguir.

gcloud ml speech operations describe OPERATION_ID

Você também poderá pesquisar a operação até que ela seja concluída executando o comando a seguir.

gcloud ml speech operations wait OPERATION_ID

Após a conclusão da operação, ela retornará uma transcrição do áudio no formato JSON.

{
  "@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))

Outras linguagens

C#: Siga as Instruções de configuração do C# na página das bibliotecas de cliente e acesse Documentação de referência da Speech-to-Text para .NET.

PHP: Siga as Instruções de configuração do PHP na página das bibliotecas de cliente e acesse Documentação de referência da Speech-to-Text para PHP.

Ruby: Siga as Instruções de configuração do Ruby na página das bibliotecas de cliente e acesse Documentação de referência da Speech-to-Text para Ruby.

Como fazer upload dos resultados de transcrição para um bucket do Cloud Storage

O Speech-to-Text é compatível com o upload direto dos resultados de reconhecimento de longa duração para um bucket do Cloud Storage. Se você implementar esse recurso com gatilhos do Cloud Storage, os uploads do Cloud Storage poderão acionar notificações que chamam o Cloud Functions e eliminam a necessidade de pesquisar resultados da Speech-to-Text.

Para que os resultados sejam enviados para um bucket do Cloud Storage, forneça a configuração de saída TranscriptOutputConfig opcional na sua solicitação de reconhecimento de longa duração.

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

Protocolo

Consulte o endpoint da API longrunningrecognize para ver todos os detalhes.

Veja no exemplo a seguir como enviar uma solicitação POST usando curl, onde o corpo da solicitação especifica o caminho para um bucket do Cloud Storage. Os resultados são enviados para esse local como um arquivo JSON que armazena 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"

O LongRunningRecognizeResponse inclui o caminho para o bucket do Cloud Storage em que houve tentativa de fazer upload. Se o upload não foi bem-sucedido, um erro de saída será retornado. Se já existir um arquivo com o mesmo nome, o upload gravará os resultados em um novo arquivo com um carimbo de data/hora como o sufixo.

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

Faça um teste

Se você ainda não conhece o Google Cloud, crie uma conta para avaliar o desempenho da Speech-to-Text em cenários reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

Faça um teste gratuito da Speech-to-Text