Início Rápido: Reconhecer e converter uma fala em texto

Neste início rápido, você vai experimentar a conversão de fala em texto em tempo real no Azure AI Foundry.

Pré-requisitos

Experimentar a conversão de fala em texto em tempo real

1. Acesse seu projeto do Azure AI Foundry. Se você precisar criar um projeto, confira Criar um projeto do Azure AI Foundry.

2. Selecione Playgrounds no painel esquerdo e selecione um playground a ser usado. Neste exemplo, selecione Experimentar o playground de Fala.

   

3. Opcionalmente, você pode selecionar uma conexão diferente para usar no playground. No playground de Fala, você pode se conectar aos recursos de vários serviços dos Serviços de IA do Azure ou aos recursos do serviço de Fala.

   

4. Selecione Transcrição em tempo real.

5. Selecione Mostrar opções avançadas para configurar opções de conversão de fala em texto, como:

   • Identificação de idioma: usada para identificar os idiomas falados no áudio quando comparados com uma lista de idiomas com suporte. Para obter mais informações sobre as opções de identificação de idioma, como reconhecimento contínuo e inicial, confira Identificação de idioma.
   • Diarização de locutor: usada para identificar e separar os locutores no áudio. A diarização distingue entre os diferentes palestrantes que participam da conversa. O Serviço de fala fornece informações sobre qual locutor estava falando uma parte específica da fala transcrita. Para obter mais informações sobre a diarização de locutor, confira o início rápido Conversão de fala em texto em tempo real com a diarização de locutor.
   • Ponto de extremidade personalizado: use um modelo implantado da fala personalizada para aprimorar a precisão do reconhecimento. Para usar o modelo de linha de base da Microsoft, mantenha essa opção definida como Nenhum. Para obter mais informações sobre a fala personalizada, confira Fala Personalizada.
   • Formato de saída: escolha um entre vários formatos de saída simples e detalhados. A saída simples inclui o formato de exibição e os carimbos de data/hora. A saída detalhada inclui mais formatos (como exibição, lexical, ITN e ITN mascarado), carimbos de data/hora e listas N melhores.
   • Lista de frases: aprimore a precisão da transcrição fornecendo uma lista de frases conhecidas, como nomes de pessoas ou localizações específicas. Use vírgulas ou ponto e vírgula para separar cada valor na lista de frases. Para obter mais informações sobre as listas de frases, confira Listas de frases.

6. Selecione um arquivo de áudio para carregar ou grave um áudio em tempo real. Neste exemplo, usamos o arquivo Call1_separated_16k_health_insurance.wav disponível no repositório do SDK de Fala no GitHub. Baixe o arquivo ou use um arquivo de áudio próprio.

   

7. Você pode exibir a transcrição em tempo real na parte inferior da página.

   

8. Você pode selecionar a guia JSON para ver a saída JSON da transcrição. As propriedades incluem Offset, Duration, RecognitionStatus, Display, Lexical, ITN e muito mais.

   

Documentação de referência | Pacotes (NuGet) | Amostras adicionais no GitHub

Neste guia de início rápido, você cria e executa um aplicativo para reconhecer e transcrever fala em texto em tempo real.

Para transcrever arquivos de áudio de forma assíncrona, confira O que é transcrição em lote. Se você não tiver certeza de qual solução de conversão de fala em texto é adequada para você, confira O que é conversão de fala em texto?

Pré-requisitos

Configurar o ambiente

O SDK de Fala está disponível como um pacote NuGet e implementa o .NET Standard 2.0. Instale o SDK de Fala mais adiante neste guia. Para quaisquer outros requisitos, consulte Instalar o SDK de Fala.

Definir variáveis de ambiente

Você precisa autenticar seu aplicativo para acessar os serviços de IA do Azure. Este artigo mostra como usar variáveis de ambiente para armazenar suas credenciais. Em seguida, você poderá acessar as variáveis de ambiente do seu código para autenticar seu aplicativo. Para a produção, use um método mais seguro para armazenar e acessar suas credenciais.

Para definir a variável de ambiente da chave de recurso de Fala, abra uma janela do console e siga as instruções para o seu sistema operacional e o ambiente de desenvolvimento.

• Para definir a variável de ambiente SPEECH_KEY, substitua your-key por uma das chaves do recurso.
• Para definir a variável de ambiente SPEECH_REGION, substitua your-region por uma das regiões do recurso.

setx SPEECH_KEY your-key
setx SPEECH_REGION your-region

export SPEECH_KEY=your-key
export SPEECH_REGION=your-region

export SPEECH_KEY=your-key
export SPEECH_REGION=your-region

Reconhecer fala de um microfone

Siga estas etapas para criar um aplicativo de console e instalar o SDK de Fala.

1. Abra uma janela do prompt de comando na pasta em que você deseja o novo projeto. Execute este comando para criar um aplicativo de console com a CLI do .NET.

   dotnet new console
   

   Esse comando cria o arquivo Program.cs no diretório do projeto.

2. Instale o SDK de Fala em seu novo projeto com a CLI do .NET.

   dotnet add package Microsoft.CognitiveServices.Speech
   

3. Substitua o conteúdo do Program.cs pelo seguinte código:

   using System;
   using System.IO;
   using System.Threading.Tasks;
   using Microsoft.CognitiveServices.Speech;
   using Microsoft.CognitiveServices.Speech.Audio;
   
   class Program 
   {
       // This example requires environment variables named "SPEECH_KEY" and "SPEECH_REGION"
       static string speechKey = Environment.GetEnvironmentVariable("SPEECH_KEY");
       static string speechRegion = Environment.GetEnvironmentVariable("SPEECH_REGION");
   
       static void OutputSpeechRecognitionResult(SpeechRecognitionResult speechRecognitionResult)
       {
           switch (speechRecognitionResult.Reason)
           {
               case ResultReason.RecognizedSpeech:
                   Console.WriteLine($"RECOGNIZED: Text={speechRecognitionResult.Text}");
                   break;
               case ResultReason.NoMatch:
                   Console.WriteLine($"NOMATCH: Speech could not be recognized.");
                   break;
               case ResultReason.Canceled:
                   var cancellation = CancellationDetails.FromResult(speechRecognitionResult);
                   Console.WriteLine($"CANCELED: Reason={cancellation.Reason}");
   
                   if (cancellation.Reason == CancellationReason.Error)
                   {
                       Console.WriteLine($"CANCELED: ErrorCode={cancellation.ErrorCode}");
                       Console.WriteLine($"CANCELED: ErrorDetails={cancellation.ErrorDetails}");
                       Console.WriteLine($"CANCELED: Did you set the speech resource key and region values?");
                   }
                   break;
           }
       }
   
       async static Task Main(string[] args)
       {
           var speechConfig = SpeechConfig.FromSubscription(speechKey, speechRegion);        
           speechConfig.SpeechRecognitionLanguage = "en-US";
   
           using var audioConfig = AudioConfig.FromDefaultMicrophoneInput();
           using var speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);
   
           Console.WriteLine("Speak into your microphone.");
           var speechRecognitionResult = await speechRecognizer.RecognizeOnceAsync();
           OutputSpeechRecognitionResult(speechRecognitionResult);
       }
   }
   

4. Para alterar o idioma de reconhecimento de fala, substitua en-US por outro en-US. Por exemplo, use es-ES para espanhol (Espanha). Se você não especificar um idioma, o padrão será en-US. Para obter detalhes sobre como identificar um dos vários idiomas que podem ser falados, consulte Identificação de idioma.

5. Execute seu novo aplicativo de console para iniciar o reconhecimento de fala a partir de um microfone:

   dotnet run
   

   Importante

   Certifique-se de definir as variáveis de ambiente SPEECH_KEY e SPEECH_REGION variáveis de ambiente. Se você não definir essas variáveis, a amostra falhará com uma mensagem de erro.

6. Fale no microfone quando solicitado. O que você fala deve aparecer como texto:

   Speak into your microphone.
   RECOGNIZED: Text=I'm excited to try speech to text.
   

Comentários

Confira outras considerações:

• Este exemplo usa a operação RecognizeOnceAsync para transcrever enunciados de até 30 segundos ou até que o silêncio seja detectado. Para obter informações sobre o reconhecimento contínuo de áudios mais longos, incluindo conversas multilíngues, consulte Como reconhecer a fala.

• Para reconhecer a fala de um arquivo de áudio, use FromWavFileInput em vez de FromDefaultMicrophoneInput:

  using var audioConfig = AudioConfig.FromWavFileInput("YourAudioFile.wav");
  

• Para arquivos de áudio compactados, como MP4, instale o GStreamer e use PullAudioInputStream ou PushAudioInputStream. Para saber mais, confira Como usar áudio de entrada compactado.

Limpar os recursos

Você pode usar o portal do Azure ou a CLI (interface de linha de comando) do Azure para remover o recurso de fala que você criou.

Documentação de referência | Pacotes (NuGet) | Exemplos adicionais no GitHub

Neste guia de início rápido, você cria e executa um aplicativo para reconhecer e transcrever fala em texto em tempo real.

Para transcrever arquivos de áudio de forma assíncrona, confira O que é transcrição em lote. Se você não tiver certeza de qual solução de conversão de fala em texto é adequada para você, confira O que é conversão de fala em texto?

Pré-requisitos

Configurar o ambiente

O SDK de Fala está disponível como um pacote NuGet e implementa o .NET Standard 2.0. Instale o SDK de Fala mais adiante neste guia. Para outros requisitos, consulte Instalar o SDK de Fala.

Definir variáveis de ambiente

Você precisa autenticar seu aplicativo para acessar os serviços de IA do Azure. Este artigo mostra como usar variáveis de ambiente para armazenar suas credenciais. Em seguida, você poderá acessar as variáveis de ambiente do seu código para autenticar seu aplicativo. Para a produção, use um método mais seguro para armazenar e acessar suas credenciais.

Para definir a variável de ambiente da chave de recurso de Fala, abra uma janela do console e siga as instruções para o seu sistema operacional e o ambiente de desenvolvimento.

• Para definir a variável de ambiente SPEECH_KEY, substitua your-key por uma das chaves do recurso.
• Para definir a variável de ambiente SPEECH_REGION, substitua your-region por uma das regiões do recurso.

setx SPEECH_KEY your-key
setx SPEECH_REGION your-region

export SPEECH_KEY=your-key
export SPEECH_REGION=your-region

export SPEECH_KEY=your-key
export SPEECH_REGION=your-region

Reconhecer fala de um microfone

Siga estas etapas para criar um aplicativo de console e instalar o SDK de Fala.

1. Crie um novo projeto de console C++ no Visual Studio Community chamado SpeechRecognition.

2. Selecione Ferramentas>Gerenciador de pacotes Nuget>Console do gerenciador de pacotes. No Console do gerenciador de pacotes, execute este comando:

   Install-Package Microsoft.CognitiveServices.Speech
   

3. Substitua o conteúdo de SpeechRecognition.cpp pelo seguinte código:

   #include <iostream> 
   #include <stdlib.h>
   #include <speechapi_cxx.h>
   
   using namespace Microsoft::CognitiveServices::Speech;
   using namespace Microsoft::CognitiveServices::Speech::Audio;
   
   std::string GetEnvironmentVariable(const char* name);
   
   int main()
   {
       // This example requires environment variables named "SPEECH_KEY" and "SPEECH_REGION"
       auto speechKey = GetEnvironmentVariable("SPEECH_KEY");
       auto speechRegion = GetEnvironmentVariable("SPEECH_REGION");
   
       if ((size(speechKey) == 0) || (size(speechRegion) == 0)) {
           std::cout << "Please set both SPEECH_KEY and SPEECH_REGION environment variables." << std::endl;
           return -1;
       }
   
       auto speechConfig = SpeechConfig::FromSubscription(speechKey, speechRegion);
   
       speechConfig->SetSpeechRecognitionLanguage("en-US");
   
       auto audioConfig = AudioConfig::FromDefaultMicrophoneInput();
       auto speechRecognizer = SpeechRecognizer::FromConfig(speechConfig, audioConfig);
   
       std::cout << "Speak into your microphone.\n";
       auto result = speechRecognizer->RecognizeOnceAsync().get();
   
       if (result->Reason == ResultReason::RecognizedSpeech)
       {
           std::cout << "RECOGNIZED: Text=" << result->Text << std::endl;
       }
       else if (result->Reason == ResultReason::NoMatch)
       {
           std::cout << "NOMATCH: Speech could not be recognized." << std::endl;
       }
       else if (result->Reason == ResultReason::Canceled)
       {
           auto cancellation = CancellationDetails::FromResult(result);
           std::cout << "CANCELED: Reason=" << (int)cancellation->Reason << std::endl;
   
           if (cancellation->Reason == CancellationReason::Error)
           {
               std::cout << "CANCELED: ErrorCode=" << (int)cancellation->ErrorCode << std::endl;
               std::cout << "CANCELED: ErrorDetails=" << cancellation->ErrorDetails << std::endl;
               std::cout << "CANCELED: Did you set the speech resource key and region values?" << std::endl;
           }
       }
   }
   
   std::string GetEnvironmentVariable(const char* name)
   {
   #if defined(_MSC_VER)
       size_t requiredSize = 0;
       (void)getenv_s(&requiredSize, nullptr, 0, name);
       if (requiredSize == 0)
       {
           return "";
       }
       auto buffer = std::make_unique<char[]>(requiredSize);
       (void)getenv_s(&requiredSize, buffer.get(), requiredSize, name);
       return buffer.get();
   #else
       auto value = getenv(name);
       return value ? value : "";
   #endif
   }
   

4. Para alterar o idioma de reconhecimento de fala, substitua en-US por outro en-US. Por exemplo, use es-ES para espanhol (Espanha). Se você não especificar um idioma, o padrão será en-US. Para obter detalhes sobre como identificar um dos vários idiomas que podem ser falados, consulte Identificação de idioma.

5. Compile e execute seu novo aplicativo de console para iniciar o reconhecimento de fala a partir de um microfone.

   Importante

   Certifique-se de definir as variáveis de ambiente SPEECH_KEY e SPEECH_REGION variáveis de ambiente. Se você não definir essas variáveis, a amostra falhará com uma mensagem de erro.

6. Fale no microfone quando solicitado. O que você fala deve aparecer como texto:

   Speak into your microphone.
   RECOGNIZED: Text=I'm excited to try speech to text.
   

Comentários

Confira outras considerações:

• Este exemplo usa a operação RecognizeOnceAsync para transcrever enunciados de até 30 segundos ou até que o silêncio seja detectado. Para obter informações sobre o reconhecimento contínuo de áudios mais longos, incluindo conversas multilíngues, consulte Como reconhecer a fala.

• Para reconhecer a fala de um arquivo de áudio, use FromWavFileInput em vez de FromDefaultMicrophoneInput:

  auto audioConfig = AudioConfig::FromWavFileInput("YourAudioFile.wav");
  

• Para arquivos de áudio compactados, como MP4, instale o GStreamer e use PullAudioInputStream ou PushAudioInputStream. Para saber mais, confira Como usar áudio de entrada compactado.

Limpar os recursos

Você pode usar o portal do Azure ou a CLI (interface de linha de comando) do Azure para remover o recurso de fala que você criou.

Documentação de referência | Pacote (Go) | Amostras adicionais no GitHub

Neste guia de início rápido, você cria e executa um aplicativo para reconhecer e transcrever fala em texto em tempo real.

Para transcrever arquivos de áudio de forma assíncrona, confira O que é transcrição em lote. Se você não tiver certeza de qual solução de conversão de fala em texto é adequada para você, confira O que é conversão de fala em texto?

Pré-requisitos

Configurar o ambiente

Instalar o SDK de Fala para Go. Para obter requisitos e instruções, consulte Instalar o SDK de Fala.

Definir variáveis de ambiente

Você precisa autenticar seu aplicativo para acessar os serviços de IA do Azure. Este artigo mostra como usar variáveis de ambiente para armazenar suas credenciais. Em seguida, você poderá acessar as variáveis de ambiente do seu código para autenticar seu aplicativo. Para a produção, use um método mais seguro para armazenar e acessar suas credenciais.

Para definir a variável de ambiente da chave de recurso de Fala, abra uma janela do console e siga as instruções para o seu sistema operacional e o ambiente de desenvolvimento.

• Para definir a variável de ambiente SPEECH_KEY, substitua your-key por uma das chaves do recurso.
• Para definir a variável de ambiente SPEECH_REGION, substitua your-region por uma das regiões do recurso.

setx SPEECH_KEY your-key
setx SPEECH_REGION your-region

export SPEECH_KEY=your-key
export SPEECH_REGION=your-region

export SPEECH_KEY=your-key
export SPEECH_REGION=your-region

Reconhecer fala de um microfone

Siga estas etapas para criar um módulo GO.

1. Abra uma janela do prompt de comando na pasta em que você deseja o novo projeto. Crie um novo arquivo chamado speech-recognition.go.

2. Copie o seguinte código em speech-recognition.go:

   package main
   
   import (
       "bufio"
       "fmt"
       "os"
   
       "github.com/Microsoft/cognitive-services-speech-sdk-go/audio"
       "github.com/Microsoft/cognitive-services-speech-sdk-go/speech"
   )
   
   func sessionStartedHandler(event speech.SessionEventArgs) {
       defer event.Close()
       fmt.Println("Session Started (ID=", event.SessionID, ")")
   }
   
   func sessionStoppedHandler(event speech.SessionEventArgs) {
       defer event.Close()
       fmt.Println("Session Stopped (ID=", event.SessionID, ")")
   }
   
   func recognizingHandler(event speech.SpeechRecognitionEventArgs) {
       defer event.Close()
       fmt.Println("Recognizing:", event.Result.Text)
   }
   
   func recognizedHandler(event speech.SpeechRecognitionEventArgs) {
       defer event.Close()
       fmt.Println("Recognized:", event.Result.Text)
   }
   
   func cancelledHandler(event speech.SpeechRecognitionCanceledEventArgs) {
       defer event.Close()
       fmt.Println("Received a cancellation: ", event.ErrorDetails)
       fmt.Println("Did you set the speech resource key and region values?")
   }
   
   func main() {
       // This example requires environment variables named "SPEECH_KEY" and "SPEECH_REGION"
       speechKey :=  os.Getenv("SPEECH_KEY")
       speechRegion := os.Getenv("SPEECH_REGION")
   
       audioConfig, err := audio.NewAudioConfigFromDefaultMicrophoneInput()
       if err != nil {
           fmt.Println("Got an error: ", err)
           return
       }
       defer audioConfig.Close()
       speechConfig, err := speech.NewSpeechConfigFromSubscription(speechKey, speechRegion)
       if err != nil {
           fmt.Println("Got an error: ", err)
           return
       }
       defer speechConfig.Close()
       speechRecognizer, err := speech.NewSpeechRecognizerFromConfig(speechConfig, audioConfig)
       if err != nil {
           fmt.Println("Got an error: ", err)
           return
       }
       defer speechRecognizer.Close()
       speechRecognizer.SessionStarted(sessionStartedHandler)
       speechRecognizer.SessionStopped(sessionStoppedHandler)
       speechRecognizer.Recognizing(recognizingHandler)
       speechRecognizer.Recognized(recognizedHandler)
       speechRecognizer.Canceled(cancelledHandler)
       speechRecognizer.StartContinuousRecognitionAsync()
       defer speechRecognizer.StopContinuousRecognitionAsync()
       bufio.NewReader(os.Stdin).ReadBytes('\n')
   }
   

3. Execute os comandos a seguir para criar um arquivo go.mod vinculado aos componentes hospedados no GitHub:

   go mod init speech-recognition
   go get github.com/Microsoft/cognitive-services-speech-sdk-go
   

   Importante

   Certifique-se de definir as variáveis de ambiente SPEECH_KEY e SPEECH_REGION variáveis de ambiente. Se você não definir essas variáveis, a amostra falhará com uma mensagem de erro.

4. Compile e execute o código:

   go build
   go run speech-recognition
   

Limpar os recursos

Você pode usar o portal do Azure ou a CLI (interface de linha de comando) do Azure para remover o recurso de fala que você criou.

Documentação de referência | Amostras adicionais no GitHub

Neste guia de início rápido, você cria e executa um aplicativo para reconhecer e transcrever fala em texto em tempo real.

Para transcrever arquivos de áudio de forma assíncrona, confira O que é transcrição em lote. Se você não tiver certeza de qual solução de conversão de fala em texto é adequada para você, confira O que é conversão de fala em texto?

Pré-requisitos

Configurar o ambiente

Para configurar o seu ambiente, instale o SDK de Fala. O exemplo deste guia de início rápido funciona com o Runtime Java.

1. Instale o Apache Maven. Em seguida, execute mvn -v para confirmar a instalação bem-sucedida.

2. Crie um novo arquivo pom.xml na raiz do projeto e copie nele o seguinte código:

   <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
       <modelVersion>4.0.0</modelVersion>
       <groupId>com.microsoft.cognitiveservices.speech.samples</groupId>
       <artifactId>quickstart-eclipse</artifactId>
       <version>1.0.0-SNAPSHOT</version>
       <build>
           <sourceDirectory>src</sourceDirectory>
           <plugins>
           <plugin>
               <artifactId>maven-compiler-plugin</artifactId>
               <version>3.7.0</version>
               <configuration>
               <source>1.8</source>
               <target>1.8</target>
               </configuration>
           </plugin>
           </plugins>
       </build>
       <dependencies>
           <dependency>
           <groupId>com.microsoft.cognitiveservices.speech</groupId>
           <artifactId>client-sdk</artifactId>
           <version>1.42.0</version>
           </dependency>
       </dependencies>
   </project>
   

3. Instale o SDK de Fala e as dependências.

   mvn clean dependency:copy-dependencies
   

Definir variáveis de ambiente

Você precisa autenticar seu aplicativo para acessar os serviços de IA do Azure. Este artigo mostra como usar variáveis de ambiente para armazenar suas credenciais. Em seguida, você poderá acessar as variáveis de ambiente do seu código para autenticar seu aplicativo. Para a produção, use um método mais seguro para armazenar e acessar suas credenciais.

Para definir a variável de ambiente da chave de recurso de Fala, abra uma janela do console e siga as instruções para o seu sistema operacional e o ambiente de desenvolvimento.

• Para definir a variável de ambiente SPEECH_KEY, substitua your-key por uma das chaves do recurso.
• Para definir a variável de ambiente SPEECH_REGION, substitua your-region por uma das regiões do recurso.

setx SPEECH_KEY your-key
setx SPEECH_REGION your-region

export SPEECH_KEY=your-key
export SPEECH_REGION=your-region

export SPEECH_KEY=your-key
export SPEECH_REGION=your-region

Reconhecer fala de um microfone

Siga estas etapas para criar um aplicativo de console para reconhecimento de fala.

1. Crie um novo arquivo chamado SpeechRecognition.java no mesmo diretório raiz do projeto.

2. Copie o seguinte código em SpeechRecognition.java:

   import com.microsoft.cognitiveservices.speech.*;
   import com.microsoft.cognitiveservices.speech.audio.AudioConfig;
   
   import java.util.concurrent.ExecutionException;
   import java.util.concurrent.Future;
   
   public class SpeechRecognition {
       // This example requires environment variables named "SPEECH_KEY" and "SPEECH_REGION"
       private static String speechKey = System.getenv("SPEECH_KEY");
       private static String speechRegion = System.getenv("SPEECH_REGION");
   
       public static void main(String[] args) throws InterruptedException, ExecutionException {
           SpeechConfig speechConfig = SpeechConfig.fromSubscription(speechKey, speechRegion);
           speechConfig.setSpeechRecognitionLanguage("en-US");
           recognizeFromMicrophone(speechConfig);
       }
   
       public static void recognizeFromMicrophone(SpeechConfig speechConfig) throws InterruptedException, ExecutionException {
           AudioConfig audioConfig = AudioConfig.fromDefaultMicrophoneInput();
           SpeechRecognizer speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);
   
           System.out.println("Speak into your microphone.");
           Future<SpeechRecognitionResult> task = speechRecognizer.recognizeOnceAsync();
           SpeechRecognitionResult speechRecognitionResult = task.get();
   
           if (speechRecognitionResult.getReason() == ResultReason.RecognizedSpeech) {
               System.out.println("RECOGNIZED: Text=" + speechRecognitionResult.getText());
           }
           else if (speechRecognitionResult.getReason() == ResultReason.NoMatch) {
               System.out.println("NOMATCH: Speech could not be recognized.");
           }
           else if (speechRecognitionResult.getReason() == ResultReason.Canceled) {
               CancellationDetails cancellation = CancellationDetails.fromResult(speechRecognitionResult);
               System.out.println("CANCELED: Reason=" + cancellation.getReason());
   
               if (cancellation.getReason() == CancellationReason.Error) {
                   System.out.println("CANCELED: ErrorCode=" + cancellation.getErrorCode());
                   System.out.println("CANCELED: ErrorDetails=" + cancellation.getErrorDetails());
                   System.out.println("CANCELED: Did you set the speech resource key and region values?");
               }
           }
   
           System.exit(0);
       }
   }
   

3. Para alterar o idioma de reconhecimento de fala, substitua en-US por outro en-US. Por exemplo, use es-ES para espanhol (Espanha). Se você não especificar um idioma, o padrão será en-US. Para obter detalhes sobre como identificar um dos vários idiomas que podem ser falados, consulte Identificação de idioma.

4. Execute seu novo aplicativo de console para iniciar o reconhecimento de fala a partir de um microfone:

   javac SpeechRecognition.java -cp ".;target\dependency\*"
   java -cp ".;target\dependency\*" SpeechRecognition
   

   Importante

   Certifique-se de definir as variáveis de ambiente SPEECH_KEY e SPEECH_REGION variáveis de ambiente. Se você não definir essas variáveis, a amostra falhará com uma mensagem de erro.

5. Fale no microfone quando solicitado. O que você fala deve aparecer como texto:

   Speak into your microphone.
   RECOGNIZED: Text=I'm excited to try speech to text.
   

Comentários

Confira outras considerações:

• Este exemplo usa a operação RecognizeOnceAsync para transcrever enunciados de até 30 segundos ou até que o silêncio seja detectado. Para obter informações sobre o reconhecimento contínuo de áudios mais longos, incluindo conversas multilíngues, consulte Como reconhecer a fala.

• Para reconhecer a fala de um arquivo de áudio, use fromWavFileInput em vez de fromDefaultMicrophoneInput:

  AudioConfig audioConfig = AudioConfig.fromWavFileInput("YourAudioFile.wav");
  

• Para arquivos de áudio compactados, como MP4, instale o GStreamer e use PullAudioInputStream ou PushAudioInputStream. Para saber mais, confira Como usar áudio de entrada compactado.

Limpar os recursos

Você pode usar o portal do Azure ou a CLI (interface de linha de comando) do Azure para remover o recurso de fala que você criou.

Documentação de referência | Pacote (npm) | Exemplos adicionais no GitHub | Código-fonte de biblioteca

Neste guia de início rápido, você cria e executa um aplicativo para reconhecer e transcrever fala em texto em tempo real.

Para transcrever arquivos de áudio de forma assíncrona, confira O que é transcrição em lote. Se você não tiver certeza de qual solução de conversão de fala em texto é adequada para você, confira O que é conversão de fala em texto?

Pré-requisitos

Você também precisa de um arquivo de áudio .wav em seu computador local. Você pode usar seu próprio arquivo .wav (de até 30 segundos) ou baixar o arquivo de exemplo https://crbn.us/whatstheweatherlike.wav.

Configurar o ambiente

Para configurar o seu ambiente, instale o SDK de Fala para JavaScript. Execute este comando: npm install microsoft-cognitiveservices-speech-sdk. Para obter instruções de instalação guiadas, consulte Instalar o SDK de Fala.

Definir variáveis de ambiente

Você precisa autenticar seu aplicativo para acessar os serviços de IA do Azure. Este artigo mostra como usar variáveis de ambiente para armazenar suas credenciais. Em seguida, você poderá acessar as variáveis de ambiente do seu código para autenticar seu aplicativo. Para a produção, use um método mais seguro para armazenar e acessar suas credenciais.

Para definir a variável de ambiente da chave de recurso de Fala, abra uma janela do console e siga as instruções para o seu sistema operacional e o ambiente de desenvolvimento.

• Para definir a variável de ambiente SPEECH_KEY, substitua your-key por uma das chaves do recurso.
• Para definir a variável de ambiente SPEECH_REGION, substitua your-region por uma das regiões do recurso.

setx SPEECH_KEY your-key
setx SPEECH_REGION your-region

export SPEECH_KEY=your-key
export SPEECH_REGION=your-region

export SPEECH_KEY=your-key
export SPEECH_REGION=your-region

Reconhecer a fala de um arquivo

Siga estas etapas para criar um aplicativo de console Node.js para reconhecimento de fala.

1. Abra uma janela do prompt de comando em que você deseja o novo projeto e crie um novo arquivo chamado SpeechRecognition.js.

2. Instale o SDK de Fala para JavaScript:

   npm install microsoft-cognitiveservices-speech-sdk
   

3. Copie o seguinte código em SpeechRecognition.js:

   const fs = require("fs");
   const sdk = require("microsoft-cognitiveservices-speech-sdk");
   
   // This example requires environment variables named "SPEECH_KEY" and "SPEECH_REGION"
   const speechConfig = sdk.SpeechConfig.fromSubscription(process.env.SPEECH_KEY, process.env.SPEECH_REGION);
   speechConfig.speechRecognitionLanguage = "en-US";
   
   function fromFile() {
       let audioConfig = sdk.AudioConfig.fromWavFileInput(fs.readFileSync("YourAudioFile.wav"));
       let speechRecognizer = new sdk.SpeechRecognizer(speechConfig, audioConfig);
   
       speechRecognizer.recognizeOnceAsync(result => {
           switch (result.reason) {
               case sdk.ResultReason.RecognizedSpeech:
                   console.log(`RECOGNIZED: Text=${result.text}`);
                   break;
               case sdk.ResultReason.NoMatch:
                   console.log("NOMATCH: Speech could not be recognized.");
                   break;
               case sdk.ResultReason.Canceled:
                   const cancellation = sdk.CancellationDetails.fromResult(result);
                   console.log(`CANCELED: Reason=${cancellation.reason}`);
   
                   if (cancellation.reason == sdk.CancellationReason.Error) {
                       console.log(`CANCELED: ErrorCode=${cancellation.ErrorCode}`);
                       console.log(`CANCELED: ErrorDetails=${cancellation.errorDetails}`);
                       console.log("CANCELED: Did you set the speech resource key and region values?");
                   }
                   break;
           }
           speechRecognizer.close();
       });
   }
   fromFile();
   

4. Em SpeechRecognition.js, substitua YourAudioFile.wav pelo seu próprio arquivo .wav. Este exemplo só reconhece a fala de um arquivo .wav. Para obter informações sobre outros formatos de áudio, confira Como usar áudio de entrada compactado. Este exemplo dá suporte a um áudio de até 30 segundos.

5. Para alterar o idioma de reconhecimento de fala, substitua en-US por outro en-US. Por exemplo, use es-ES para espanhol (Espanha). Se você não especificar um idioma, o padrão será en-US. Para obter detalhes sobre como identificar um dos vários idiomas que podem ser falados, consulte Identificação de idioma.

6. Execute seu novo aplicativo de console para iniciar o reconhecimento de fala a partir de um arquivo:

   node.exe SpeechRecognition.js
   

   Importante

   Certifique-se de definir as variáveis de ambiente SPEECH_KEY e SPEECH_REGION variáveis de ambiente. Se você não definir essas variáveis, a amostra falhará com uma mensagem de erro.

   A fala do arquivo de áudio deve sair como texto:

   RECOGNIZED: Text=I'm excited to try speech to text.
   

Comentários

Este exemplo usa a operação recognizeOnceAsync para transcrever enunciados de até 30 segundos ou até que o silêncio seja detectado. Para obter informações sobre o reconhecimento contínuo de áudios mais longos, incluindo conversas multilíngues, consulte Como reconhecer a fala.

Limpar os recursos

Você pode usar o portal do Azure ou a CLI (interface de linha de comando) do Azure para remover o recurso de fala que você criou.

Documentação de referência | Pacote (PyPi) | Amostras adicionais no GitHub

Neste guia de início rápido, você cria e executa um aplicativo para reconhecer e transcrever fala em texto em tempo real.

Para transcrever arquivos de áudio de forma assíncrona, confira O que é transcrição em lote. Se você não tiver certeza de qual solução de conversão de fala em texto é adequada para você, confira O que é conversão de fala em texto?

Pré-requisitos

Configurar o ambiente

O SDK de fala para Python está disponível como um módulo PyPI (índice de pacote do Python). O SDK de Fala para Python é compatível com Windows, Linux e macOS.

• Para o Windows, instale os Pacotes Redistribuíveis do Visual C++ para Visual Studio 2015, 2017, 2019 e 2022 para sua plataforma. Quando você instalar esse pacote pela primeira vez, poderá ser necessária uma reinicialização.
• No Linux, você deve usar a arquitetura de destino x64.

Instale uma versão do Python a partir da versão 3.7 ou posterior. Para outros requisitos, consulte Instalar o SDK de Fala.

Definir variáveis de ambiente

Você precisa autenticar seu aplicativo para acessar os serviços de IA do Azure. Este artigo mostra como usar variáveis de ambiente para armazenar suas credenciais. Em seguida, você poderá acessar as variáveis de ambiente do seu código para autenticar seu aplicativo. Para a produção, use um método mais seguro para armazenar e acessar suas credenciais.

Para definir a variável de ambiente da chave de recurso de Fala, abra uma janela do console e siga as instruções para o seu sistema operacional e o ambiente de desenvolvimento.

• Para definir a variável de ambiente SPEECH_KEY, substitua your-key por uma das chaves do recurso.
• Para definir a variável de ambiente SPEECH_REGION, substitua your-region por uma das regiões do recurso.

setx SPEECH_KEY your-key
setx SPEECH_REGION your-region

export SPEECH_KEY=your-key
export SPEECH_REGION=your-region

export SPEECH_KEY=your-key
export SPEECH_REGION=your-region

Reconhecer fala de um microfone

Siga estas etapas para criar um aplicativo de console.

1. Abra uma janela do prompt de comando na pasta em que você deseja o novo projeto. Crie um novo arquivo chamado speech_recognition.py.

2. Execute este comando para instalar o SDK de Fala:

   pip install azure-cognitiveservices-speech
   

3. Copie o seguinte código em speech_recognition.py:

   import os
   import azure.cognitiveservices.speech as speechsdk
   
   def recognize_from_microphone():
       # This example requires environment variables named "SPEECH_KEY" and "SPEECH_REGION"
       speech_config = speechsdk.SpeechConfig(subscription=os.environ.get('SPEECH_KEY'), region=os.environ.get('SPEECH_REGION'))
       speech_config.speech_recognition_language="en-US"
   
       audio_config = speechsdk.audio.AudioConfig(use_default_microphone=True)
       speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config, audio_config=audio_config)
   
       print("Speak into your microphone.")
       speech_recognition_result = speech_recognizer.recognize_once_async().get()
   
       if speech_recognition_result.reason == speechsdk.ResultReason.RecognizedSpeech:
           print("Recognized: {}".format(speech_recognition_result.text))
       elif speech_recognition_result.reason == speechsdk.ResultReason.NoMatch:
           print("No speech could be recognized: {}".format(speech_recognition_result.no_match_details))
       elif speech_recognition_result.reason == speechsdk.ResultReason.Canceled:
           cancellation_details = speech_recognition_result.cancellation_details
           print("Speech Recognition canceled: {}".format(cancellation_details.reason))
           if cancellation_details.reason == speechsdk.CancellationReason.Error:
               print("Error details: {}".format(cancellation_details.error_details))
               print("Did you set the speech resource key and region values?")
   
   recognize_from_microphone()
   

4. Para alterar o idioma de reconhecimento de fala, substitua en-US por outro en-US. Por exemplo, use es-ES para espanhol (Espanha). Se você não especificar um idioma, o padrão será en-US. Para obter detalhes sobre como identificar um dos vários idiomas que podem ser falados, consulte identificação do idioma.

5. Execute seu novo aplicativo de console para iniciar o reconhecimento de fala a partir de um microfone:

   python speech_recognition.py
   

   Importante

   Certifique-se de definir as variáveis de ambiente SPEECH_KEY e SPEECH_REGION variáveis de ambiente. Se você não definir essas variáveis, a amostra falhará com uma mensagem de erro.

6. Fale no microfone quando solicitado. O que você fala deve aparecer como texto:

   Speak into your microphone.
   RECOGNIZED: Text=I'm excited to try speech to text.
   

Comentários

Confira outras considerações:

• Este exemplo usa a operação recognize_once_async para transcrever enunciados de até 30 segundos ou até que o silêncio seja detectado. Para obter informações sobre o reconhecimento contínuo de áudios mais longos, incluindo conversas multilíngues, consulte Como reconhecer a fala.

• Para reconhecer a fala de um arquivo de áudio, use filename em vez de use_default_microphone:

  audio_config = speechsdk.audio.AudioConfig(filename="YourAudioFile.wav")
  

• Para arquivos de áudio compactados, como MP4, instale o GStreamer e use PullAudioInputStream ou PushAudioInputStream. Para saber mais, confira Como usar áudio de entrada compactado.

Limpar os recursos

Você pode usar o portal do Azure ou a CLI (interface de linha de comando) do Azure para remover o recurso de fala que você criou.

Documentação de referência | Pacotes (download) | Amostras adicionais no GitHub

Neste guia de início rápido, você cria e executa um aplicativo para reconhecer e transcrever fala em texto em tempo real.

Para transcrever arquivos de áudio de forma assíncrona, confira O que é transcrição em lote. Se você não tiver certeza de qual solução de conversão de fala em texto é adequada para você, confira O que é conversão de fala em texto?

Pré-requisitos

Configurar o ambiente

O SDK de Fala para Swift é distribuído como um pacote de estrutura. A estrutura dá suporte a Objective-C e Swift no iOS e no macOS.

O SDK de Fala pode ser usado em projetos do Xcode como um CocoaPod, ou baixado diretamente e vinculado manualmente. Este guia usa um CocoaPod. Instale o gerenciador de dependência do CocoaPod conforme descrito nas instruções de instalação.

Definir variáveis de ambiente

Você precisa autenticar seu aplicativo para acessar os serviços de IA do Azure. Este artigo mostra como usar variáveis de ambiente para armazenar suas credenciais. Em seguida, você poderá acessar as variáveis de ambiente do seu código para autenticar seu aplicativo. Para a produção, use um método mais seguro para armazenar e acessar suas credenciais.

Para definir a variável de ambiente da chave de recurso de Fala, abra uma janela do console e siga as instruções para o seu sistema operacional e o ambiente de desenvolvimento.

• Para definir a variável de ambiente SPEECH_KEY, substitua your-key por uma das chaves do recurso.
• Para definir a variável de ambiente SPEECH_REGION, substitua your-region por uma das regiões do recurso.

setx SPEECH_KEY your-key
setx SPEECH_REGION your-region

export SPEECH_KEY=your-key
export SPEECH_REGION=your-region

export SPEECH_KEY=your-key
export SPEECH_REGION=your-region

Reconhecer fala de um microfone

Siga estas etapas para reconhecer a fala em um aplicativo macOS.

1. Clone o repositório Azure-Samples/cognitive-services-speech-sdk para obter o projeto de exemplo Reconhecer fala a partir de um microfone em Swift no MacOS. O repositório também tem exemplos de iOS.

2. Navegue até o diretório do aplicativo de exemplo baixado (helloworld) em um terminal.

3. Execute o comando pod install. Esse comando gera um espaço de trabalho do Xcode helloworld.xcworkspace que contém o aplicativo de amostra e o SDK de Fala como uma dependência.

4. Abra o workspace helloworld.xcworkspace no Xcode.

5. Abra o arquivo chamado AppDelegate.swift e localize os métodos applicationDidFinishLaunching e recognizeFromMic como mostrado aqui.

   import Cocoa
   
   @NSApplicationMain
   class AppDelegate: NSObject, NSApplicationDelegate {
       var label: NSTextField!
       var fromMicButton: NSButton!
   
       var sub: String!
       var region: String!
   
       @IBOutlet weak var window: NSWindow!
   
       func applicationDidFinishLaunching(_ aNotification: Notification) {
           print("loading")
           // load subscription information
           sub = ProcessInfo.processInfo.environment["SPEECH_KEY"]
           region = ProcessInfo.processInfo.environment["SPEECH_REGION"]
   
           label = NSTextField(frame: NSRect(x: 100, y: 50, width: 200, height: 200))
           label.textColor = NSColor.black
           label.lineBreakMode = .byWordWrapping
   
           label.stringValue = "Recognition Result"
           label.isEditable = false
   
           self.window.contentView?.addSubview(label)
   
           fromMicButton = NSButton(frame: NSRect(x: 100, y: 300, width: 200, height: 30))
           fromMicButton.title = "Recognize"
           fromMicButton.target = self
           fromMicButton.action = #selector(fromMicButtonClicked)
           self.window.contentView?.addSubview(fromMicButton)
       }
   
       @objc func fromMicButtonClicked() {
           DispatchQueue.global(qos: .userInitiated).async {
               self.recognizeFromMic()
           }
       }
   
       func recognizeFromMic() {
           var speechConfig: SPXSpeechConfiguration?
           do {
               try speechConfig = SPXSpeechConfiguration(subscription: sub, region: region)
           } catch {
               print("error \(error) happened")
               speechConfig = nil
           }
           speechConfig?.speechRecognitionLanguage = "en-US"
   
           let audioConfig = SPXAudioConfiguration()
   
           let reco = try! SPXSpeechRecognizer(speechConfiguration: speechConfig!, audioConfiguration: audioConfig)
   
           reco.addRecognizingEventHandler() {reco, evt in
               print("intermediate recognition result: \(evt.result.text ?? "(no result)")")
               self.updateLabel(text: evt.result.text, color: .gray)
           }
   
           updateLabel(text: "Listening ...", color: .gray)
           print("Listening...")
   
           let result = try! reco.recognizeOnce()
           print("recognition result: \(result.text ?? "(no result)"), reason: \(result.reason.rawValue)")
           updateLabel(text: result.text, color: .black)
   
           if result.reason != SPXResultReason.recognizedSpeech {
               let cancellationDetails = try! SPXCancellationDetails(fromCanceledRecognitionResult: result)
               print("cancelled: \(result.reason), \(cancellationDetails.errorDetails)")
               print("Did you set the speech resource key and region values?")
               updateLabel(text: "Error: \(cancellationDetails.errorDetails)", color: .red)
           }
       }
   
       func updateLabel(text: String?, color: NSColor) {
           DispatchQueue.main.async {
               self.label.stringValue = text!
               self.label.textColor = color
           }
       }
   }
   

6. Em AppDelegate.m, use as variáveis de ambiente que você definiu anteriormente para a chave de recurso de Fala e região.

   sub = ProcessInfo.processInfo.environment["SPEECH_KEY"]
   region = ProcessInfo.processInfo.environment["SPEECH_REGION"]
   

7. Para alterar o idioma de reconhecimento de fala, substitua en-US por outro en-US. Por exemplo, use es-ES para espanhol (Espanha). Se você não especificar um idioma, o padrão será en-US. Para obter detalhes sobre como identificar um dos vários idiomas que podem ser falados, consulte Identificação de idioma.

8. Para tornar a saída de depuração visível, selecione Exibir>Área de Depuração>Ativar Console.

9. Compile e execute o código de exemplo selecionando Produto>Executar no menu ou selecionando o botão Reproduzir.

   Importante

   Certifique-se de definir as variáveis de ambiente SPEECH_KEY e SPEECH_REGION variáveis de ambiente. Se você não definir essas variáveis, a amostra falhará com uma mensagem de erro.

Depois de selecionar o botão no aplicativo e dizer algumas palavras, você deverá ver o texto que falou na parte inferior da tela. Quando você executa o aplicativo pela primeira vez, ele solicita que você conceda acesso ao microfone do seu computador.

Comentários

Este exemplo usa a operação recognizeOnce para transcrever enunciados de até 30 segundos ou até que o silêncio seja detectado. Para obter informações sobre o reconhecimento contínuo de áudios mais longos, incluindo conversas multilíngues, consulte Como reconhecer a fala.

Objective-C

O SDK de Fala para Objective-C compartilha bibliotecas de clientes e documentação de referência com o SDK de Fala para Swift. Para ver exemplos de código Objective-C, confira o projeto de exemplo Reconhecer a fala de um microfone em Objective-C no macOS no GitHub.

Limpar os recursos

Você pode usar o portal do Azure ou a CLI (interface de linha de comando) do Azure para remover o recurso de fala que você criou.

Referência da API REST de conversão de fala em texto | Referência da API REST de conversão de fala em texto para áudios curtos | Amostras adicionais no GitHub

Neste guia de início rápido, você cria e executa um aplicativo para reconhecer e transcrever fala em texto em tempo real.

Para transcrever arquivos de áudio de forma assíncrona, confira O que é transcrição em lote. Se você não tiver certeza de qual solução de conversão de fala em texto é adequada para você, confira O que é conversão de fala em texto?

Pré-requisitos

Você também precisa de um arquivo de áudio .wav em seu computador local. Você pode usar seu próprio arquivo .wav de até 60 segundos ou baixar o arquivo de exemplo https://crbn.us/whatstheweatherlike.wav.

Definir variáveis de ambiente

Você precisa autenticar seu aplicativo para acessar os serviços de IA do Azure. Este artigo mostra como usar variáveis de ambiente para armazenar suas credenciais. Em seguida, você poderá acessar as variáveis de ambiente do seu código para autenticar seu aplicativo. Para a produção, use um método mais seguro para armazenar e acessar suas credenciais.

Para definir a variável de ambiente da chave de recurso de Fala, abra uma janela do console e siga as instruções para o seu sistema operacional e o ambiente de desenvolvimento.

• Para definir a variável de ambiente SPEECH_KEY, substitua your-key por uma das chaves do recurso.
• Para definir a variável de ambiente SPEECH_REGION, substitua your-region por uma das regiões do recurso.

setx SPEECH_KEY your-key
setx SPEECH_REGION your-region

export SPEECH_KEY=your-key
export SPEECH_REGION=your-region

export SPEECH_KEY=your-key
export SPEECH_REGION=your-region

Reconhecer a fala de um arquivo

Abra uma janela do console e execute o seguinte comando cURL. Substitua YourAudioFile.wav pelo caminho e nome do seu arquivo de áudio.

curl --location --request POST "https://%SPEECH_REGION%.stt.speech.microsoft.com/speech/recognition/conversation/cognitiveservices/v1?language=en-US&format=detailed" ^
--header "Ocp-Apim-Subscription-Key: %SPEECH_KEY%" ^
--header "Content-Type: audio/wav" ^
--data-binary "@YourAudioFile.wav"

audio_file=@'YourAudioFile.wav'

curl --location --request POST \
"https://${SPEECH_REGION}.stt.speech.microsoft.com/speech/recognition/conversation/cognitiveservices/v1?language=en-US&format=detailed" \
--header "Ocp-Apim-Subscription-Key: ${SPEECH_KEY}" \
--header "Content-Type: audio/wav" \
--data-binary $audio_file

audio_file=@'YourAudioFile.wav'

curl --location --request POST \
"https://${SPEECH_REGION}.stt.speech.microsoft.com/speech/recognition/conversation/cognitiveservices/v1?language=en-US&format=detailed" \
--header "Ocp-Apim-Subscription-Key: ${SPEECH_KEY}" \
--header "Content-Type: audio/wav" \
--data-binary $audio_file

Você deve receber uma resposta semelhante ao que é mostrado aqui. O DisplayText deve ser o texto que foi reconhecido do arquivo de áudio. O comando reconhece até 60 segundos de áudio e o converte em texto.

{
    "RecognitionStatus": "Success",
    "DisplayText": "My voice is my passport, verify me.",
    "Offset": 6600000,
    "Duration": 32100000
}

Para obter mais informações, confira a API REST de conversão de fala em texto para áudios curtos.

Limpar os recursos

Você pode usar o portal do Azure ou a CLI (interface de linha de comando) do Azure para remover o recurso de fala que você criou.

Neste guia de início rápido, você cria e executa um aplicativo para reconhecer e transcrever fala em texto em tempo real.

Para transcrever arquivos de áudio de forma assíncrona, confira O que é transcrição em lote. Se você não tiver certeza de qual solução de conversão de fala em texto é adequada para você, confira O que é conversão de fala em texto?

Pré-requisitos

Configurar o ambiente

Siga estas etapas e consulte o início rápido da CLI de Fala para obter outros requisitos para sua plataforma.

1. Execute o seguinte comando da CLI do .NET para instalar a CLI de Fala:

   dotnet tool install --global Microsoft.CognitiveServices.Speech.CLI
   

2. Execute os comandos a seguir para configurar a chave e a região do recurso Fala. Substitua SUBSCRIPTION-KEY pela sua chave do recurso de Fala e substitua REGION pela sua região do recurso de Fala.

   • Terminal
   • PowerShell

   spx config @key --set SUBSCRIPTION-KEY
   spx config @region --set REGION
   

Reconhecer fala de um microfone

1. Execute o comando a seguir para iniciar o reconhecimento de fala a partir de um microfone:

   spx recognize --microphone --source en-US
   

2. Fale próximo ao microfone e você verá a transcrição de suas palavras em texto em tempo real. A CLI de Fala é interrompida após um período de silêncio, 30 segundos ou ao selecionar Ctrl+C.

   Connection CONNECTED...
   RECOGNIZED: I'm excited to try speech to text.
   

Comentários

Confira outras considerações:

• Para reconhecer a fala de um arquivo de áudio, use --file em vez de --microphone. Para arquivos de áudio compactados, como MP4, instale o GStreamer e use --format. Para saber mais, confira Como usar áudio de entrada compactado.

  • Terminal
  • PowerShell

  spx recognize --file YourAudioFile.wav
  spx recognize --file YourAudioFile.mp4 --format any
  

• Para melhorar a precisão do reconhecimento de palavras específicas ou enunciados, use uma lista de frases. Você inclui uma lista de frases em linha ou com um arquivo de texto junto com o comando recognize:

  • Terminal
  • PowerShell

  spx recognize --microphone --phrases "Contoso;Jessie;Rehaan;"
  spx recognize --microphone --phrases @phrases.txt
  

• Para alterar o idioma de reconhecimento de fala, substitua en-US por outro en-US. Por exemplo, use es-ES para espanhol (Espanha). Se você não especificar um idioma, o padrão será en-US.

  spx recognize --microphone --source es-ES
  

• Para reconhecimento contínuo de áudio por mais de 30 segundos, acrescente --continuous:

  spx recognize --microphone --source es-ES --continuous
  

• Execute este comando para obter informações sobre mais opções de reconhecimento de fala, como entrada e saída de arquivo:

  spx help recognize
  

Limpar os recursos

Você pode usar o portal do Azure ou a CLI (interface de linha de comando) do Azure para remover o recurso de fala que você criou.