Bibliotecas de cliente da Speech-to-Text

}

Nesta página, você verá como dar os primeiros passos com as bibliotecas de cliente do Cloud para a API Speech-to-Text. Aqui, você lê mais sobre as bibliotecas de cliente das APIs do Cloud, incluindo as bibliotecas de cliente das APIs do Google mais antigas.

Como instalar a biblioteca de cliente

C#

Para mais informações, consulte Como configurar um ambiente de desenvolvimento em C#.

Install-Package Google.Cloud.Speech.V1 -Pre

Go

Para mais informações, consulte Como configurar um ambiente de desenvolvimento do Go.

go get -u cloud.google.com/go/speech/apiv1

Java

Para mais informações, consulte Como configurar um ambiente de desenvolvimento em Java.

Se você estiver usando o Maven, adicione isto ao arquivo pom.xml:

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>com.google.cloud</groupId>
      <artifactId>libraries-bom</artifactId>
      <version>5.3.0</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

<dependencies>
  <dependency>
    <groupId>com.google.cloud</groupId>
    <artifactId>google-cloud-speech</artifactId>
  </dependency>

Se estiver usando o Gradle, adicione o seguinte às suas dependências:

compile 'com.google.cloud:google-cloud-speech:1.23.0'

Se você estiver usando o sbt, adicione isto às dependências:

libraryDependencies += "com.google.cloud" % "google-cloud-speech" % "1.23.0"

Caso você esteja usando o IntelliJ ou o Eclipse, poderá adicionar bibliotecas de cliente ao seu projeto usando estes plug-ins de ambiente de desenvolvimento integrado:

Os plug-ins também oferecem outras funcionalidades, como gerenciamento de chaves de contas de serviço. Consulte a documentação de cada plug-in para mais detalhes.

Node.js

Para mais informações, consulte Como configurar um ambiente de desenvolvimento em Node.js.

npm install --save @google-cloud/speech

PHP

Para mais informações, consulte Como usar o PHP no Google Cloud.

composer require google/cloud-speech

Python

Para mais informações, consulte Como configurar um ambiente de desenvolvimento do Python.

pip install --upgrade google-cloud-speech

Ruby

Para mais informações, consulte Como configurar um ambiente de desenvolvimento em Ruby.

gem install google-cloud-speech

Como configurar a autenticação

Para executar a biblioteca de cliente, é preciso primeiro configurar a autenticação. Para isso, crie uma conta de serviço e defina uma variável de ambiente. Conclua as etapas a seguir para configurar a autenticação. Para outras formas de autenticação, consulte a documentação de autenticação do GCP.

Cloud Console

  1. No Console do Cloud, acesse a página Criar chave da conta de serviço.

    Acessar página "Criar chave da conta de serviço"
  2. Na lista Conta de serviço, selecione Nova conta de serviço.
  3. No campo Nome da conta de serviço, insira um nome.
  4. Na lista Papel, selecione Projeto > Proprietário.

    Observação: o campo Papel autoriza sua conta de serviço a acessar recursos. É possível visualizar e alterar esse campo mais tarde usando o Console do Cloud. Se você estiver desenvolvendo um aplicativo de produção, especifique permissões mais granulares do que Projeto > Proprietário. Para mais informações, consulte Como atribuir papéis a contas de serviço.
  5. Clique em Criar. O download de um arquivo JSON que contém a chave é feito no computador.

Linha de comando

É possível executar os seguintes comandos usando o SDK do Cloud na máquina local ou no Cloud Shell.

  1. Crie a conta de serviço. Substitua [NAME] por um nome para a conta de serviço.

    gcloud iam service-accounts create [NAME]
  2. Conceda permissões à conta de serviço. Substitua [PROJECT-ID] pelo ID do projeto.

    gcloud projects add-iam-policy-binding [PROJECT_ID] --member "serviceAccount:[NAME]@[PROJECT_ID].iam.gserviceaccount.com" --role "roles/owner"
    Observação: o campo Papel autoriza a conta de serviço a acessar recursos. Se quiser visualizar e alterar esse campo mais tarde, use o Console do Cloud. Se você estiver desenvolvendo um aplicativo de produção, especifique permissões mais granulares do que Projeto > Proprietário. Para mais informações, consulte Como atribuir papéis a contas de serviço.
  3. Gere o arquivo de chave. Substitua [FILE_NAME] pelo nome do arquivo de chave.

    gcloud iam service-accounts keys create [FILE_NAME].json --iam-account [NAME]@[PROJECT_ID].iam.gserviceaccount.com

Forneça as credenciais de autenticação ao código do aplicativo ao definir a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS. Substitua [PATH] pelo caminho do arquivo JSON com a chave da conta de serviço e [FILE_NAME] pelo nome de arquivo. Essa variável só se aplica à sessão de shell atual. Dessa maneira, se você abrir uma nova sessão, precisará definir a variável novamente.

Linux ou macOS

export GOOGLE_APPLICATION_CREDENTIALS="[PATH]"

Por exemplo:

export GOOGLE_APPLICATION_CREDENTIALS="/home/user/Downloads/[FILE_NAME].json"

Windows

Com o PowerShell:

$env:GOOGLE_APPLICATION_CREDENTIALS="[PATH]"

Exemplo:

$env:GOOGLE_APPLICATION_CREDENTIALS="C:\Users\username\Downloads\[FILE_NAME].json"

Com o prompt de comando:

set GOOGLE_APPLICATION_CREDENTIALS=[PATH]

Como usar a biblioteca de cliente

O exemplo a seguir mostra como usar a biblioteca de cliente.

C#


    using Google.Cloud.Speech.V1;
    using System;

    namespace GoogleCloudSamples
    {
        public class QuickStart
        {
            // The name of the local audio file to transcribe
            public static string DEMO_FILE = "audio.raw";
            public static void Main(string[] args)
            {
                var speech = SpeechClient.Create();
                var response = speech.Recognize(new RecognitionConfig()
                {
                    Encoding = RecognitionConfig.Types.AudioEncoding.Linear16,
                    SampleRateHertz = 16000,
                    LanguageCode = "en",
                }, RecognitionAudio.FromFile(DEMO_FILE));
                foreach (var result in response.Results)
                {
                    foreach (var alternative in result.Alternatives)
                    {
                        Console.WriteLine(alternative.Transcript);
                    }
                }
            }
        }
    }

Go


    // Sample speech-quickstart uses the Google Cloud Speech API to transcribe
    // audio.
    package main

    import (
    	"context"
    	"fmt"
    	"io/ioutil"
    	"log"

    	speech "cloud.google.com/go/speech/apiv1"
    	speechpb "google.golang.org/genproto/googleapis/cloud/speech/v1"
    )

    func main() {
    	ctx := context.Background()

    	// Creates a client.
    	client, err := speech.NewClient(ctx)
    	if err != nil {
    		log.Fatalf("Failed to create client: %v", err)
    	}

    	// Sets the name of the audio file to transcribe.
    	filename := "/path/to/audio.raw"

    	// Reads the audio file into memory.
    	data, err := ioutil.ReadFile(filename)
    	if err != nil {
    		log.Fatalf("Failed to read file: %v", err)
    	}

    	// Detects speech in the audio file.
    	resp, err := client.Recognize(ctx, &speechpb.RecognizeRequest{
    		Config: &speechpb.RecognitionConfig{
    			Encoding:        speechpb.RecognitionConfig_LINEAR16,
    			SampleRateHertz: 16000,
    			LanguageCode:    "en-US",
    		},
    		Audio: &speechpb.RecognitionAudio{
    			AudioSource: &speechpb.RecognitionAudio_Content{Content: data},
    		},
    	})
    	if err != nil {
    		log.Fatalf("failed to recognize: %v", err)
    	}

    	// Prints the results.
    	for _, result := range resp.Results {
    		for _, alt := range result.Alternatives {
    			fmt.Printf("\"%v\" (confidence=%3f)\n", alt.Transcript, alt.Confidence)
    		}
    	}
    }
    

Java

// Imports the Google Cloud client library
    import com.google.cloud.speech.v1.RecognitionAudio;
    import com.google.cloud.speech.v1.RecognitionConfig;
    import com.google.cloud.speech.v1.RecognitionConfig.AudioEncoding;
    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;
    import java.util.List;

    public class QuickstartSample {

      /** Demonstrates using the Speech API to transcribe an audio file. */
      public static void main(String... args) throws Exception {
        // Instantiates a client
        try (SpeechClient speechClient = SpeechClient.create()) {

          // The path to the audio file to transcribe
          String fileName = "./resources/audio.raw";

          // Reads the audio file into memory
          Path path = Paths.get(fileName);
          byte[] data = Files.readAllBytes(path);
          ByteString audioBytes = ByteString.copyFrom(data);

          // Builds the sync recognize request
          RecognitionConfig config =
              RecognitionConfig.newBuilder()
                  .setEncoding(AudioEncoding.LINEAR16)
                  .setSampleRateHertz(16000)
                  .setLanguageCode("en-US")
                  .build();
          RecognitionAudio audio = RecognitionAudio.newBuilder().setContent(audioBytes).build();

          // Performs speech recognition on the audio file
          RecognizeResponse response = speechClient.recognize(config, audio);
          List<SpeechRecognitionResult> results = response.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

async function main() {
      // Imports the Google Cloud client library
      const speech = require('@google-cloud/speech');
      const fs = require('fs');

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

      // The name of the audio file to transcribe
      const fileName = './resources/audio.raw';

      // Reads a local audio file and converts it to base64
      const file = fs.readFileSync(fileName);
      const audioBytes = file.toString('base64');

      // The audio file's encoding, sample rate in hertz, and BCP-47 language code
      const audio = {
        content: audioBytes,
      };
      const config = {
        encoding: 'LINEAR16',
        sampleRateHertz: 16000,
        languageCode: 'en-US',
      };
      const request = {
        audio: audio,
        config: config,
      };

      // 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}`);
    }
    main().catch(console.error);

PHP

# Includes the autoloader for libraries installed with composer
    require __DIR__ . '/vendor/autoload.php';

    # Imports the Google Cloud client library
    use Google\Cloud\Speech\V1\SpeechClient;
    use Google\Cloud\Speech\V1\RecognitionAudio;
    use Google\Cloud\Speech\V1\RecognitionConfig;
    use Google\Cloud\Speech\V1\RecognitionConfig\AudioEncoding;

    # The name of the audio file to transcribe
    $audioFile = __DIR__ . '/test/data/audio32KHz.raw';

    # get contents of a file into a string
    $content = file_get_contents($audioFile);

    # set string as audio content
    $audio = (new RecognitionAudio())
        ->setContent($content);

    # The audio file's encoding, sample rate and language
    $config = new RecognitionConfig([
        'encoding' => AudioEncoding::LINEAR16,
        'sample_rate_hertz' => 32000,
        'language_code' => 'en-US'
    ]);

    # Instantiates a client
    $client = new SpeechClient();

    # Detects speech in the audio file
    $response = $client->recognize($config, $audio);

    # Print most likely transcription
    foreach ($response->getResults() as $result) {
        $alternatives = $result->getAlternatives();
        $mostLikely = $alternatives[0];
        $transcript = $mostLikely->getTranscript();
        printf('Transcript: %s' . PHP_EOL, $transcript);
    }

    $client->close();
    

Python

from google.cloud import speech_v1p1beta1
    from google.cloud.speech_v1p1beta1 import enums

    def sample_recognize(storage_uri):
        """
        Performs synchronous speech recognition on an audio file

        Args:
          storage_uri URI for audio file in Cloud Storage, e.g. gs://[BUCKET]/[FILE]
        """

        client = speech_v1p1beta1.SpeechClient()

        # storage_uri = 'gs://cloud-samples-data/speech/brooklyn_bridge.mp3'

        # The language of the supplied audio
        language_code = "en-US"

        # Sample rate in Hertz of the audio data sent
        sample_rate_hertz = 44100

        # Encoding of audio data sent. This sample sets this explicitly.
        # This field is optional for FLAC and WAV audio formats.
        encoding = enums.RecognitionConfig.AudioEncoding.MP3
        config = {
            "language_code": language_code,
            "sample_rate_hertz": sample_rate_hertz,
            "encoding": encoding,
        }
        audio = {"uri": storage_uri}

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

    

Ruby

# Imports the Google Cloud client library
    require "google/cloud/speech"

    # Instantiates a client
    speech = Google::Cloud::Speech.new

    # The name of the audio file to transcribe
    file_name = "./resources/audio.raw"

    # The raw audio
    audio_file = File.binread file_name

    # The audio file's encoding and sample rate
    config = { encoding:          :LINEAR16,
               sample_rate_hertz: 16_000,
               language_code:     "en-US" }
    audio  = { content: audio_file }

    # Detects speech in the audio file
    response = speech.recognize config, audio

    results = response.results

    # Get first result because we only processed a single audio file
    # Each result represents a consecutive portion of the audio
    results.first.alternatives.each do |alternatives|
      puts "Transcription: #{alternatives.transcript}"
    end

Outros recursos