Esta página foi traduzida pela API Cloud Translation.

Como 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 áudios com mais de um minuto. Para áudios mais curtos, o reconhecimento de fala síncrono é mais rápido e mais simples.

É 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 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 uma resposta de operação longrunningrecognize típica, consulte a documentação Princípios básicos do Speech-to-Text.

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. Nele, é usado o token de acesso de uma conta de serviço configurada para o projeto usando o SDK do Cloud do Google Cloud. Consulte o guia de início rápido para ver instruções de como instalar o SDK do Cloud, configurar um projeto com uma conta de serviço e conseguir um token de acesso.

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"

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. Você pode ver o progresso estimado da solicitação no campo 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"

Se a solicitação for bem-sucedida, o servidor retornará 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": "okay so what am I doing here...(etc)...",
            "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 voz assíncrono, use a ferramenta de linha de comando gcloud, 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

Ver no GitHub Feedback


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

Ver no GitHub Feedback

/**
 * 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 {
  // Instantiates a client with GOOGLE_APPLICATION_CREDENTIALS
  try (SpeechClient speech = SpeechClient.create()) {

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

Ver no GitHub Feedback

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

Ver no GitHub Feedback

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

Outros idiomas

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

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

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

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

O Speech-to-Text é compatível com o upload dos resultados de reconhecimento de longa duração diretamente para um bucket do Cloud Storage. Essa funcionalidade é um recurso de visualização. Se você implementar esse recurso com os Gatilhos do Cloud Storage, os uploads do Cloud Storage poderão acionar notificações que chamem o Cloud Functions e eliminar a necessidade. para pesquisar os resultados de reconhecimento de 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 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.

O exemplo a seguir mostra 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 GCS em que o upload foi tentado. Se o upload falhar, um erro de saída será retornado. Se já houver um arquivo com o mesmo nome, o upload gravará os resultados em um novo arquivo com um carimbo de data/hora como sufixo.

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

Faça um teste

Se você é novo no Google Cloud, crie uma conta para avaliar o desempenho do Speech-to-Text em cenários reais. Clientes novos recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

Faça uma avaliação gratuita do Speech-to-Text