Como transcrever áudio de smartphone com modelos aprimorados

v1 /speech-to-text/docs/reference/rest/ /speech-to-text/docs/reference/rpc/google.cloud.speech.

Neste tutorial, veja como transcrever a gravação de áudio de um smartphone usando o Speech-to-Text.

Os arquivos de áudio podem ter várias origens diferentes. Os dados de áudio podem vir de um smartphone (como um correio de voz) ou de uma trilha sonora incluída em um arquivo de vídeo.

Na Speech-to-Text, é possível usar um dos vários modelos de machine learning para transcrever o arquivo de áudio, com a finalidade de conseguir a melhor correspondência com a fonte original do áudio. Especifique a fonte do áudio original para conseguir melhores resultados na transcrição do áudio. Dessa maneira, a Speech-to-Text processa os arquivos de áudio usando um modelo de machine learning treinado para dados similares aos contidos no arquivo de áudio.

Objetivos

  • Enviar uma solicitação de transcrição de áudio para o áudio gravado de um smartphone (como um correio de voz) à Speech-to-Text.
  • Especificar um modelo aprimorado de reconhecimento de fala para uma solicitação de transcrição de áudio.

Custos

Neste tutorial, são usados componentes do Cloud Platform que podem ser cobrados, incluindo:

  • Speech-to-Text

Use a Calculadora de preços para gerar uma estimativa de custo com base no uso previsto. Usuários novos do Cloud Platform podem ter direito a uma avaliação gratuita.

Antes de começar

Os pré-requisitos para este tutorial são:

Como enviar uma solicitação

Para transcrever melhor o áudio capturado em um smartphone, como em uma ligação ou um correio de voz, defina o campo model no payload RecognitionConfig como phone_model. O campo model informa à API Speech-to-Text qual modelo de reconhecimento de fala usar para a solicitação de transcrição.

É possível melhorar os resultados da transcrição do áudio de smartphone usando um modelo aprimorado. Para usar um modelo avançado, defina o campo useEnhanced como true no seu payload RecognitionConfig.

Nas amostras de código a seguir, veja como selecionar um modelo de transcrição específico ao chamar a Speech-to-Text.

Protocolo

Consulte o endpoint da API speech:recognize 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 que usa o SDK do Cloud do Google Cloud. Consulte o Guia de início rápido para 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 -s -H "Content-Type: application/json" \
        -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
        https://speech.googleapis.com/v1/speech:recognize \
        --data '{
        "config": {
            "encoding": "LINEAR16",
            "languageCode": "en-US",
            "enableWordTimeOffsets": false,
            "enableAutomaticPunctuation": true,
            "model": "phone_call",
            "useEnhanced": true
        },
        "audio": {
            "uri": "gs://cloud-samples-tests/speech/commercial_mono.wav"
        }
    }'
    

Consulte a documentação de referência RecognitionConfig 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:

    {
      "results": [
        {
          "alternatives": [
            {
              "transcript": "Hi, I'd like to buy a Chromecast. I was wondering whether you could help me with that.",
              "confidence": 0.8930228
            }
          ],
          "resultEndTime": "5.640s"
        },
        {
          "alternatives": [
            {
              "transcript": " Certainly, which color would you like? We are blue black and red.",
              "confidence": 0.9101991
            }
          ],
          "resultEndTime": "10.220s"
        },
        {
          "alternatives": [
            {
              "transcript": " Let's go with the black one.",
              "confidence": 0.8818244
            }
          ],
          "resultEndTime": "13.870s"
        },
        {
          "alternatives": [
            {
              "transcript": " Would you like the new Chromecast Ultra model or the regular Chromecast?",
              "confidence": 0.94733626
            }
          ],
          "resultEndTime": "18.460s"
        },
        {
          "alternatives": [
            {
              "transcript": " Regular Chromecast is fine. Thank you. Okay. Sure. Would you like to ship it regular or Express?",
              "confidence": 0.9519095
            }
          ],
          "resultEndTime": "25.930s"
        },
        {
          "alternatives": [
            {
              "transcript": " Express, please.",
              "confidence": 0.9101229
            }
          ],
          "resultEndTime": "28.260s"
        },
        {
          "alternatives": [
            {
              "transcript": " Terrific. It's on the way. Thank you. Thank you very much. Bye.",
              "confidence": 0.9321616
            }
          ],
          "resultEndTime": "34.150s"
        }
     ]
    }
    

C#

static object SyncRecognizeEnhancedModel(string filePath)
    {
        var speech = SpeechClient.Create();
        var response = speech.Recognize(new RecognitionConfig()
        {
            Encoding = RecognitionConfig.Types.AudioEncoding.Linear16,
            SampleRateHertz = 8000,
            LanguageCode = "en-US",
            // Enhanced models are only available for projects that
            // opt into audio data logging.
            UseEnhanced = true,
            // A model must be specified to use an enhanced model.
            Model = "phone_call",
        }, RecognitionAudio.FromFile(filePath));
        foreach (var result in response.Results)
        {
            foreach (var alternative in result.Alternatives)
            {
                Console.WriteLine(alternative.Transcript);
            }
        }
        return 0;
    }

Go


    func enhancedModel(w io.Writer, path string) error {
    	ctx := context.Background()

    	client, err := speech.NewClient(ctx)
    	if err != nil {
    		return fmt.Errorf("NewClient: %v", err)
    	}

    	// path = "../testdata/commercial_mono.wav"
    	data, err := ioutil.ReadFile(path)
    	if err != nil {
    		return fmt.Errorf("ReadFile: %v", err)
    	}

    	resp, err := client.Recognize(ctx, &speechpb.RecognizeRequest{
    		Config: &speechpb.RecognitionConfig{
    			Encoding:        speechpb.RecognitionConfig_LINEAR16,
    			SampleRateHertz: 8000,
    			LanguageCode:    "en-US",
    			UseEnhanced:     true,
    			// A model must be specified to use enhanced model.
    			Model: "phone_call",
    		},
    		Audio: &speechpb.RecognitionAudio{
    			AudioSource: &speechpb.RecognitionAudio_Content{Content: data},
    		},
    	})
    	if err != nil {
    		return fmt.Errorf("Recognize: %v", err)
    	}

    	for i, result := range resp.Results {
    		fmt.Fprintf(w, "%s\n", strings.Repeat("-", 20))
    		fmt.Fprintf(w, "Result %d\n", i+1)
    		for j, alternative := range result.Alternatives {
    			fmt.Fprintf(w, "Alternative %d: %s\n", j+1, alternative.Transcript)
    		}
    	}
    	return nil
    }
    

Java

/*
     * Please include the following imports to run this sample.
     *
     * import com.google.cloud.speech.v1.RecognitionAudio;
     * import com.google.cloud.speech.v1.RecognitionConfig;
     * import com.google.cloud.speech.v1.RecognizeRequest;
     * import com.google.cloud.speech.v1.RecognizeResponse;
     * import com.google.cloud.speech.v1.SpeechClient;
     * import com.google.cloud.speech.v1.SpeechRecognitionAlternative;
     * import com.google.cloud.speech.v1.SpeechRecognitionResult;
     * import com.google.protobuf.ByteString;
     * import java.nio.file.Files;
     * import java.nio.file.Path;
     * import java.nio.file.Paths;
     */

    public static void sampleRecognize() {
      // TODO(developer): Replace these variables before running the sample.
      String localFilePath = "resources/hello.wav";
      String model = "phone_call";
      sampleRecognize(localFilePath, model);
    }

    /**
     * Transcribe a short audio file using a specified transcription model
     *
     * @param localFilePath Path to local audio file, e.g. /path/audio.wav
     * @param model The transcription model to use, e.g. video, phone_call, default For a list of
     *     available transcription models, see:
     *     https://cloud.google.com/speech-to-text/docs/transcription-model#transcription_models
     */
    public static void sampleRecognize(String localFilePath, String model) {
      try (SpeechClient speechClient = SpeechClient.create()) {

        // The language of the supplied audio
        String languageCode = "en-US";
        RecognitionConfig config =
            RecognitionConfig.newBuilder().setModel(model).setLanguageCode(languageCode).build();
        Path path = Paths.get(localFilePath);
        byte[] data = Files.readAllBytes(path);
        ByteString content = ByteString.copyFrom(data);
        RecognitionAudio audio = RecognitionAudio.newBuilder().setContent(content).build();
        RecognizeRequest request =
            RecognizeRequest.newBuilder().setConfig(config).setAudio(audio).build();
        RecognizeResponse response = speechClient.recognize(request);
        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 for Beta API
    /**
     * TODO(developer): Update client library import to use new
     * version of API when desired features become available
     */
    const speech = require('@google-cloud/speech').v1p1beta1;
    const fs = require('fs');

    // Creates a client
    const client = new speech.SpeechClient();

    /**
     * TODO(developer): Uncomment the following lines before running the sample.
     */
    // const filename = 'Local path to audio file, e.g. /path/to/audio.raw';
    // const model = 'Model to use, e.g. phone_call, video, default';
    // 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,
      model: model,
    };
    const audio = {
      content: fs.readFileSync(filename).toString('base64'),
    };

    const request = {
      config: config,
      audio: audio,
    };

    // Detects speech in the audio file
    const [response] = await client.recognize(request);
    const transcription = response.results
      .map(result => result.alternatives[0].transcript)
      .join('\n');
    console.log('Transcription: ', transcription);

Python

from google.cloud import speech_v1
    import io

    def sample_recognize(local_file_path, model):
        """
        Transcribe a short audio file using a specified transcription model

        Args:
          local_file_path Path to local audio file, e.g. /path/audio.wav
          model The transcription model to use, e.g. video, phone_call, default
          For a list of available transcription models, see:
          https://cloud.google.com/speech-to-text/docs/transcription-model#transcription_models
        """

        client = speech_v1.SpeechClient()

        # local_file_path = 'resources/hello.wav'
        # model = 'phone_call'

        # The language of the supplied audio
        language_code = "en-US"
        config = {"model": model, "language_code": language_code}
        with io.open(local_file_path, "rb") as f:
            content = f.read()
        audio = {"content": content}

        response = client.recognize(config, audio)
        for result in response.results:
            # First alternative is the most probable result
            alternative = result.alternatives[0]
            print(u"Transcript: {}".format(alternative.transcript))

    

Como fazer limpeza

Para evitar que os recursos usados neste tutorial sejam cobrados na conta do Google Cloud Platform, veja:

Como excluir o projeto

O jeito mais fácil de evitar cobranças é excluindo o projeto que você criou para o tutorial.

Para excluir o projeto:

  1. No Console do Cloud, acesse a página Gerenciar recursos:

    Acessar a página Gerenciar recursos

  2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
  3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

Excluir instâncias

Para excluir uma instância do Compute Engine:

  1. No Console do Cloud, acesse a página Instâncias de VM.

    Acessar a página "Instâncias de VMs"

  2. Marque a caixa de seleção da a instância que você quer excluir.
  3. Clique em Excluir para excluir a instância.

Como excluir regras de firewall para a rede padrão

Para excluir uma regra de firewall:

  1. No Console do Cloud, acesse a página Regras de firewall:

    Acessar a página "Regras de firewall"

  2. Clique na caixa de seleção da a regra de firewall que você quer excluir.
  3. Clique em Excluir para remover a regra de firewall.