Esta página foi traduzida pela API Cloud Translation.

Transcreva ficheiros de áudio longos em texto

Esta página demonstra como transcrever ficheiros de áudio longos (com mais de 1 minuto) para texto através da API Speech-to-Text e do reconhecimento de voz assíncrono.

Acerca do reconhecimento de voz assíncrono

O reconhecimento de voz assíncrono inicia uma operação de processamento de áudio de longa duração. Use o reconhecimento de voz assíncrono para transcrever áudio com mais de 60 segundos. Para áudio mais curto, o reconhecimento de voz síncrono é mais rápido e simples. O limite superior para o reconhecimento de voz assíncrono é de 480 minutos.

Conversão de voz em texto e processamento assíncrono

O conteúdo de áudio pode ser enviado diretamente para o Speech-to-Text a partir de um ficheiro local para processamento assíncrono. No entanto, o limite de tempo de áudio para ficheiros locais é de 60 segundos. A tentativa de transcrever ficheiros de áudio locais com mais de 60 segundos resulta num erro. Para usar o reconhecimento de voz assíncrono para transcrever áudio com mais de 60 segundos, tem de ter os seus dados guardados num contentor do Google Cloud Storage.

Pode obter os resultados da operação através do método google.longrunning.Operations. Os resultados permanecem disponíveis para obtenção durante 5 dias (120 horas). Também tem a opção de carregar os resultados diretamente para um contentor do Google Cloud Storage.

Transcreva ficheiros de áudio longos através de um ficheiro do Google Cloud Storage

Estas amostras usam um contentor do Cloud Storage para armazenar a entrada de áudio não processada para o processo de transcrição de longa duração. Para ver um exemplo de uma resposta de operação típica, consulte a documentação de referência.longrunningrecognize

Protocolo

Consulte o ponto final da API speech:longrunningrecognize para ver os detalhes completos.

Para realizar o reconhecimento de voz síncrono, faça um pedido POST e forneça o corpo do pedido adequado. O exemplo seguinte mostra um pedido POST com curl. O exemplo usa a Google Cloud CLI para gerar um token de acesso. Para ver instruções sobre a instalação da CLI gcloud, consulte o 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 a documentação de referência RecognitionConfig e RecognitionAudio para obter mais informações sobre a configuração do corpo do pedido.

Se o pedido for bem-sucedido, o servidor devolve um código de estado HTTP 200 OK e a resposta no formato JSON:

{
  "name": "7612202767953098924"
}

em que name é o nome da operação de longa duração criada para o pedido.

Aguarde a conclusão do processamento. O tempo de processamento difere consoante o áudio de origem. Na maioria dos casos, recebe resultados com metade da duração do áudio de origem. Pode obter o estado da sua operação de longa duração fazendo um pedido ao ponto final https://speech.googleapis.com/v1/operations/.GET Substitua your-operation-name pelo name retornado do seu pedido de 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"

Se o pedido for bem-sucedido, o servidor devolve um código de estado 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 estiver concluída, pode sondar o ponto final fazendo repetidamente o pedido GET até que a propriedade done da resposta seja true.

gcloud

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

Para realizar o reconhecimento de voz assíncrono, use a Google Cloud CLI, indicando o caminho de um ficheiro 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 o pedido for bem-sucedido, o servidor devolve o ID da operação de longa duração no formato JSON.

{
  "name": OPERATION_ID
}

Em seguida, pode obter informações sobre a operação executando o seguinte comando.

gcloud ml speech operations describe OPERATION_ID

Também pode sondar a operação até que seja concluída executando o seguinte comando.

gcloud ml speech operations wait OPERATION_ID

Após a conclusão da operação, a operação devolve 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

Para saber como instalar e usar a biblioteca cliente do Speech-to-Text, consulte o artigo Bibliotecas cliente do Speech-to-Text. Para mais informações, consulte a documentação de referência da API Go Speech-to-Text.

Para se autenticar no Speech-to-Text, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.


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

Para se autenticar no Speech-to-Text, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

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

Para se autenticar no Speech-to-Text, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

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

Para se autenticar no Speech-to-Text, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

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

Idiomas adicionais

C#: Siga as instruções de configuração do C# na página das bibliotecas cliente e, em seguida, visite a documentação de referência do Speech-to-Text para .NET.

PHP: Siga as instruções de configuração do PHP na página das bibliotecas cliente e, em seguida, visite a documentação de referência do Speech-to-Text para PHP.

Ruby: Siga as instruções de configuração do Ruby na página das bibliotecas cliente e, em seguida, visite a documentação de referência do Speech-to-Text para Ruby.

Carregue os resultados da transcrição para um contentor do Cloud Storage

O Speech-to-Text suporta o carregamento dos resultados de reconhecimento de longa duração diretamente para um contentor do Cloud Storage. Se implementar esta funcionalidade com acionadores do Cloud Storage, os carregamentos do Cloud Storage podem acionar notificações que chamam funções da nuvem e eliminar a necessidade de sondar o Speech-to-Text para obter resultados de reconhecimento.

Para carregar os resultados para um contentor do Cloud Storage, faculte a configuração de saída opcional TranscriptOutputConfig na sua solicitação de reconhecimento de execução prolongada.

  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 ponto final da API longrunningrecognize para ver os detalhes completos.

O exemplo seguinte mostra como enviar um pedido POST usando curl, em que o corpo do pedido especifica o caminho para um contentor do Cloud Storage. Os resultados são carregados para esta localização como um ficheiro 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 elemento LongRunningRecognizeResponse inclui o caminho para o contentor do Cloud Storage onde a tentativa de carregamento foi feita. Se o carregamento não tiver sido bem-sucedido, é devolvido um erro de saída. Se já existir um ficheiro com o mesmo nome, o carregamento escreve os resultados num novo ficheiro com uma indicação de data/hora como sufixo.

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

Experimente

Se está a usar o Google Cloud pela primeira vez, crie uma conta para avaliar o desempenho do Speech-to-Text em cenários reais. Os novos clientes também recebem 300 USD em créditos gratuitos para executar, testar e implementar cargas de trabalho.

Experimente a conversão de voz em texto gratuitamente

Transcreva ficheiros de áudio longos em texto Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Acerca do reconhecimento de voz assíncrono

Conversão de voz em texto e processamento assíncrono

Transcreva ficheiros de áudio longos através de um ficheiro do Google Cloud Storage

Protocolo

gcloud

Go

Java

Node.js

Python

Idiomas adicionais

Carregue os resultados da transcrição para um contentor do Cloud Storage

Protocolo

Experimente

Transcreva ficheiros de áudio longos em texto