Como reconhecer a fala

  • Artigo

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

Nesse guia de instruções, você saberá como reconhecer e transcrever fala em texto em tempo real.

Criar uma configuração de Fala

Para chamar o serviço de fala usando o SDK de Fala, você precisa criar uma instância SpeechConfig. Essa classe inclui informações sobre sua assinatura, como sua chave e localização/região, ponto de extremidade, host ou token de autorização associados.

  1. Crie uma instância de SpeechConfig usando sua chave e localização/região.
  2. Crie um recurso de Fala no portal do Azure. Para obter mais informações, confira Criar um recurso multisserviço.
using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;

class Program 
{
    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromSubscription("YourSpeechKey", "YourSpeechRegion");
    }
}

Há algumas outras formas de inicializar SpeechConfig:

  • Usar um ponto de extremidade e passe um ponto de extremidade de serviço de Fala. Uma chave ou um token de autorização é opcional.
  • Usar um host e passe um endereço de host. Uma chave ou um token de autorização é opcional.
  • Usar um token de autorização com a região/localização associada.

Observação

Independentemente de se você estiver executando o reconhecimento de fala, a síntese de fala, tradução ou reconhecimento de intenção, você sempre criará uma configuração.

Reconhecer fala de um microfone

Para reconhecer uma fala usando o microfone do dispositivo, crie uma instância AudioConfig usando o método FromDefaultMicrophoneInput(). Em seguida, inicialize o objeto SpeechRecognizer passando speechConfig e audioConfig.

using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;

class Program 
{
    async static Task FromMic(SpeechConfig speechConfig)
    {
        using var audioConfig = AudioConfig.FromDefaultMicrophoneInput();
        using var speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);

        Console.WriteLine("Speak into your microphone.");
        var result = await speechRecognizer.RecognizeOnceAsync();
        Console.WriteLine($"RECOGNIZED: Text={result.Text}");
    }

    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromSubscription("YourSpeechKey", "YourSpeechRegion");
        await FromMic(speechConfig);
    }
}

Caso você deseje usar um dispositivo de entrada de áudio específico, especifique a identificação do dispositivo em AudioConfig. Saiba como obter a identificação do dispositivo de entrada de áudio.

Reconhecer a fala de um arquivo

Caso deseje reconhecer uma fala de um arquivo de áudio em vez de um microfone, você ainda precisa criar uma instância de AudioConfig. Mas, nesse caso, você não chama FromDefaultMicrophoneInput(). Você chama FromWavFileInput() e passa o caminho de arquivo:

using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;

class Program 
{
    async static Task FromFile(SpeechConfig speechConfig)
    {
        using var audioConfig = AudioConfig.FromWavFileInput("PathToFile.wav");
        using var speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);

        var result = await speechRecognizer.RecognizeOnceAsync();
        Console.WriteLine($"RECOGNIZED: Text={result.Text}");
    }

    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromSubscription("YourSpeechKey", "YourSpeechRegion");
        await FromFile(speechConfig);
    }
}

Reconhecer uma fala de um fluxo na memória

Para muitos casos de utilização, é provável que os seus dados de áudio venham do Armazenamento de Blobs do Azure ou já estejam na memória como uma instância byte[] ou uma estrutura de dados brutos semelhante. O exemplo a seguir usa PushAudioInputStream para reconhecer a fala, que é essencialmente um fluxo de memória abstraído. O código de exemplo faz o seguinte:

  • Grava os dados de áudio brutos (PCM) em PushAudioInputStream usando a função Write(), que aceita uma instância de byte[].
  • Lê um arquivo .wav usando FileReader para fins de demonstração. Se você já tem dados de áudio em uma instância de byte[], vá diretamente para a gravação do conteúdo no fluxo de entrada.
  • O formato padrão são dados de modulação de código de pulso mono (PCM) de 16 bits e 16 KHz. Para personalizar o formato, é possível transmitir um objeto AudioStreamFormat para CreatePushStream() usando a função estática AudioStreamFormat.GetWaveFormatPCM(sampleRate, (byte)bitRate, (byte)channels).
using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;

class Program 
{
    async static Task FromStream(SpeechConfig speechConfig)
    {
        var reader = new BinaryReader(File.OpenRead("PathToFile.wav"));
        using var audioConfigStream = AudioInputStream.CreatePushStream();
        using var audioConfig = AudioConfig.FromStreamInput(audioConfigStream);
        using var speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);

        byte[] readBytes;
        do
        {
            readBytes = reader.ReadBytes(1024);
            audioConfigStream.Write(readBytes, readBytes.Length);
        } while (readBytes.Length > 0);

        var result = await speechRecognizer.RecognizeOnceAsync();
        Console.WriteLine($"RECOGNIZED: Text={result.Text}");
    }

    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromSubscription("YourSpeechKey", "YourSpeechRegion");
        await FromStream(speechConfig);
    }
}

O uso de um fluxo por push como entrada pressupõe que os dados de áudio sejam um PCM bruto e ignora todos os cabeçalhos. A API ainda funcionará em alguns casos se o cabeçalho não tiver sido ignorado. Mas, para os melhores resultados, considere a implementação da lógica para ler os cabeçalhos, de modo que byte[] comece no início dos dados de áudio.

Tratar erros

Os exemplos anteriores apenas obterão o texto reconhecido da propriedade result.Text. Para tratar erros e outras respostas, escreva um código para processar o resultado. O código a seguir avalia a propriedade result.Reason e:

  • Imprime o resultado de reconhecimento: ResultReason.RecognizedSpeech.
  • Se não há correspondência de reconhecimento, ele informa o usuário: ResultReason.NoMatch.
  • Se um erro é encontrado, ele imprime a mensagem de erro: ResultReason.Canceled.
switch (result.Reason)
{
    case ResultReason.RecognizedSpeech:
        Console.WriteLine($"RECOGNIZED: Text={result.Text}");
        break;
    case ResultReason.NoMatch:
        Console.WriteLine($"NOMATCH: Speech could not be recognized.");
        break;
    case ResultReason.Canceled:
        var cancellation = CancellationDetails.FromResult(result);
        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;
}

Usar o reconhecimento contínuo

Os exemplos anteriores usam o reconhecimento de captura única, que reconhece uma única expressão. O fim de um único enunciado é determinado pela escuta de silêncio no fim ou até o máximo de 15 segundos de áudio processado.

Por outro lado, o reconhecimento contínuo é usado quando você deseja controlar a interrupção do reconhecimento. É necessário assinar os eventos Recognizing, Recognized e Canceled para obter os resultados do reconhecimento. Para interromper o reconhecimento, chame StopContinuousRecognitionAsync. Veja um exemplo de como o reconhecimento contínuo é realizado em um arquivo de entrada de áudio.

Comece definindo a entrada e inicializando SpeechRecognizer:

using var audioConfig = AudioConfig.FromWavFileInput("YourAudioFile.wav");
using var speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);

Depois, crie uma instância de TaskCompletionSource<int> para gerenciar o estado do reconhecimento de fala:

var stopRecognition = new TaskCompletionSource<int>();

Em seguida, assine os eventos enviados pelo SpeechRecognizer:

  • Recognizing: sinaliza os eventos que contêm os resultados intermediários de reconhecimento.
  • Recognized: sinaliza os eventos que contêm os resultados finais de reconhecimento, que indicam uma tentativa de reconhecimento bem-sucedida.
  • SessionStopped: sinaliza os eventos que indicam o fim de uma sessão de reconhecimento (operação).
  • Canceled: sinaliza os eventos que contêm os resultados de reconhecimento cancelados. Esses resultados indicam uma tentativa de reconhecimento cancelada como um resultado de uma solicitação de cancelamento direto. Como alternativa, eles indicam uma falha de protocolo ou transporte.
speechRecognizer.Recognizing += (s, e) =>
{
    Console.WriteLine($"RECOGNIZING: Text={e.Result.Text}");
};

speechRecognizer.Recognized += (s, e) =>
{
    if (e.Result.Reason == ResultReason.RecognizedSpeech)
    {
        Console.WriteLine($"RECOGNIZED: Text={e.Result.Text}");
    }
    else if (e.Result.Reason == ResultReason.NoMatch)
    {
        Console.WriteLine($"NOMATCH: Speech could not be recognized.");
    }
};

speechRecognizer.Canceled += (s, e) =>
{
    Console.WriteLine($"CANCELED: Reason={e.Reason}");

    if (e.Reason == CancellationReason.Error)
    {
        Console.WriteLine($"CANCELED: ErrorCode={e.ErrorCode}");
        Console.WriteLine($"CANCELED: ErrorDetails={e.ErrorDetails}");
        Console.WriteLine($"CANCELED: Did you set the speech resource key and region values?");
    }

    stopRecognition.TrySetResult(0);
};

speechRecognizer.SessionStopped += (s, e) =>
{
    Console.WriteLine("\n    Session stopped event.");
    stopRecognition.TrySetResult(0);
};

Com tudo isso configurado, chame StartContinuousRecognitionAsync para iniciar o reconhecimento:

await speechRecognizer.StartContinuousRecognitionAsync();

// Waits for completion. Use Task.WaitAny to keep the task rooted.
Task.WaitAny(new[] { stopRecognition.Task });

// Make the following call at some point to stop recognition:
// await speechRecognizer.StopContinuousRecognitionAsync();

Alterar o idioma de origem

Uma tarefa comum no reconhecimento de fala é especificar o idioma da entrada (ou origem). O exemplo a seguir mostra como você pode alterar o idioma de entrada para Italiano. No código, encontre a instância de SpeechConfig e adicione esta linha diretamente abaixo dela:

speechConfig.SpeechRecognitionLanguage = "it-IT";

A propriedade SpeechRecognitionLanguage espera uma cadeia de caracteres em formato idioma-localidade. Para obter mais informações, consulte a lista de localidades de conversão de fala em texto com suporte.

Identificação de idioma

Você pode usar a identificação de idioma com o Reconhecimento de conversão de fala em texto quando precisa identificar o idioma em uma fonte de áudio e transcrevê-lo em um texto.

Para obter um exemplo de código completo, consulte Identificação de idioma.

Usar um ponto de extremidade personalizado

Com a fala personalizada, você pode carregar seus próprios dados, testar e treinar um modelo personalizado, comparar a precisão entre modelos e implantar um modelo em um ponto de extremidade personalizado. O exemplo a seguir mostra como definir um ponto de extremidade personalizado.

var speechConfig = SpeechConfig.FromSubscription("YourSubscriptionKey", "YourServiceRegion");
speechConfig.EndpointId = "YourEndpointId";
var speechRecognizer = new SpeechRecognizer(speechConfig);

Executar e usar um contêiner

Os contêineres de Fala fornecem APIs de ponto de extremidade de consulta baseadas em websocket que são acessadas através do SDK de Fala e da CLI de Fala. Por padrão, o SDK de Fala e a CLI de Fala usam o serviço público de Fala. Para usar o contêiner, você precisa alterar o método de inicialização. Use uma URL de host de contêiner em vez de chave e região.

Para obter mais informações sobre contêineres, consulte URLs de host em Instalar e executar Contêineres de fala com o Docker.

Alterar a forma como o silêncio é tratado

Se espera-se que um usuário fale mais rápido ou mais devagar do que o normal, os comportamentos padrão para silêncio sem fala no áudio de entrada podem não resultar no que você espera. Os problemas comuns com o tratamento do silêncio incluem:

  • A conversão rápida de fala encadeia muitas frases em um único resultado de reconhecimento, em vez de dividir frases em resultados individuais.
  • Fala lenta separando partes de uma única frase em vários resultados.
  • Um reconhecimento único termina muito rapidamente enquanto aguarda o início da fala.

Esses problemas podem ser resolvidos definindo uma das duas propriedades de tempo limite na instância SpeechConfig usada para criar um SpeechRecognizer:

  • O tempo limite de silêncio de segmentação ajusta a quantidade de áudio não verbal permitido em uma frase que está sendo falada no momento antes que essa frase seja considerada "concluída".
    • Valores mais altos geralmente tornam os resultados mais longos e permitem pausas mais longas do orador dentro de uma frase, mas fazem com que os resultados demorem mais para chegar. Eles também podem fazer com que frases separadas se combinem em um único resultado quando definidos muito altas.
    • Valores mais baixos geralmente tornam os resultados mais curtos e garantem pausas mais rápidas e frequentes entre frases, mas também podem fazer com que frases simples se separem em vários resultados quando os valores definidos são muito baixos.
    • Esse tempo limite pode ser definido como valores inteiros entre 100 e 5.000, em milissegundos, com 500 como padrão típico.
  • OTempo limite de silêncio inicial ajusta a quantidade de áudio sem fala permitido antes que uma frase antes da tentativa de reconhecimento termine em um resultado "sem correspondência".
    • Valores mais altos dão ao orador mais tempo para reagir e começar a falar, mas também podem resultar em resposta lenta quando nada é falado.
    • Valores mais baixos garantem um resultado "sem correspondência" imediato, para uma experiência mais rápida do usuário e tratamento de áudio mais controlado, mas podem cortar um orador muito rapidamente quando definido muito baixo.
    • Como o reconhecimento contínuo gera muitos resultados, esse valor determina a frequência com que os resultados "sem correspondência" chegarão, mas não afetam o conteúdo dos resultados do reconhecimento de outra forma.
    • Esse tempo limite pode ser definido como qualquer valor inteiro não negativo, em milissegundos, ou definido como 0 para desativá-lo totalmente. 5.000 é um padrão típico para o reconhecimento único, enquanto 1.5000 é um padrão típico para reconhecimento contínuo.

Como há compensações ao modificar esses tempos limite, é recomendável apenas alterar as configurações quando um problema relacionado ao tratamento do silêncio for observado. Os valores padrão lidam de forma ideal com a maioria dos áudios falados e só devem encontrar problemas em cenários incomuns.

Exemplo: os usuários que falam um número de série como "ABC-123-4567" pausam tempo suficiente para que o número de série seja dividido em vários resultados entre grupos de caracteres. Nesse caso, tente um valor mais alto como 2000 ms para o tempo limite de silêncio de segmentação:

speechConfig.SetProperty(PropertyId.Speech_SegmentationSilenceTimeoutMs, "2000");

Exemplo: a fala de um apresentador gravada é rápida o suficiente para que várias frases em uma linha sejam combinadas, com grandes resultados de reconhecimento chegando apenas uma ou duas vezes por minuto. Nesse caso, definir o tempo limite de silêncio de segmentação como um valor mais baixo, como 300ms, pode ajudar:

speechConfig.SetProperty(PropertyId.Speech_SegmentationSilenceTimeoutMs, "300");

Exemplo: um reconhecimento único solicitando que um orador localize e leia um número de série termina muito rapidamente enquanto o número está sendo encontrado. Nesse caso, um tempo limite de silêncio inicial mais longo, como 10.000 ms, pode ajudar:

speechConfig.SetProperty(PropertyId.SpeechServiceConnection_InitialSilenceTimeoutMs, "10000");

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

Nesse guia de instruções, você saberá como reconhecer e transcrever fala em texto em tempo real.

Criar uma configuração de Fala

Para chamar o serviço de Fala usando o SDK de Fala, crie uma instância de SpeechConfig. Essa classe inclui informações sobre sua assinatura, como sua chave e localização/região, ponto de extremidade, host ou token de autorização associados.

  1. Crie uma instância de SpeechConfig usando sua chave e região.
  2. Crie um recurso de Fala no portal do Azure. Para obter mais informações, confira Criar um recurso multisserviço.
using namespace std;
using namespace Microsoft::CognitiveServices::Speech;

auto speechConfig = SpeechConfig::FromSubscription("YourSpeechKey", "YourSpeechRegion");

Há algumas outras formas de inicializar SpeechConfig:

  • Usar um ponto de extremidade e passe um ponto de extremidade de serviço de Fala. Uma chave ou um token de autorização é opcional.
  • Usar um host e passe um endereço de host. Uma chave ou um token de autorização é opcional.
  • Usar um token de autorização com a região/localização associada.

Observação

Independentemente de se você estiver executando o reconhecimento de fala, a síntese de fala, tradução ou reconhecimento de intenção, você sempre criará uma configuração.

Reconhecer fala de um microfone

Para reconhecer uma fala usando o microfone do dispositivo, crie uma instância AudioConfig usando a função de membro FromDefaultMicrophoneInput(). Em seguida, inicialize o objeto SpeechRecognizer passando audioConfig e config.

using namespace Microsoft::CognitiveServices::Speech::Audio;

auto audioConfig = AudioConfig::FromDefaultMicrophoneInput();
auto speechRecognizer = SpeechRecognizer::FromConfig(config, audioConfig);

cout << "Speak into your microphone." << std::endl;
auto result = speechRecognizer->RecognizeOnceAsync().get();
cout << "RECOGNIZED: Text=" << result->Text << std::endl;

Caso você deseje usar um dispositivo de entrada de áudio específico, especifique a identificação do dispositivo em AudioConfig. Para obter mais informações sobre como selecionar um dispositivo de entrada de áudio, consulte Selecionar um dispositivo de entrada de áudio com o SDK de Fala

Reconhecer a fala de um arquivo

Caso deseje reconhecer uma fala de um arquivo de áudio em vez de usar um microfone, você ainda precisa criar uma instância de AudioConfig. Mas, nesse caso, você não chama FromDefaultMicrophoneInput(). Você chama FromWavFileInput() e passa o caminho de arquivo:

using namespace Microsoft::CognitiveServices::Speech::Audio;

auto audioConfig = AudioConfig::FromWavFileInput("YourAudioFile.wav");
auto speechRecognizer = SpeechRecognizer::FromConfig(config, audioConfig);

auto result = speechRecognizer->RecognizeOnceAsync().get();
cout << "RECOGNIZED: Text=" << result->Text << std::endl;

Reconhecer uma fala usando a classe Recognizer

A classe Reconhecedor do SDK de Fala do C++ expõe alguns métodos que você pode usar para o reconhecimento de fala.

Reconhecimento pontual

O reconhecimento pontual reconhece de forma assíncrona um único enunciado. O fim de um único enunciado é determinado pela escuta de silêncio no fim ou até o máximo de 15 segundos de áudio processado. Veja um exemplo do reconhecimento pontual assíncrono via RecognizeOnceAsync:

auto result = speechRecognizer->RecognizeOnceAsync().get();

Será necessário escrever algum código para lidar com o resultado. Este exemplo avalia result->Reason e:

  • Imprime o resultado de reconhecimento: ResultReason::RecognizedSpeech.
  • Se não há correspondência de reconhecimento, ele informa o usuário: ResultReason::NoMatch.
  • Se um erro é encontrado, ele imprime a mensagem de erro: ResultReason::Canceled.
switch (result->Reason)
{
    case ResultReason::RecognizedSpeech:
        cout << "We recognized: " << result->Text << std::endl;
        break;
    case ResultReason::NoMatch:
        cout << "NOMATCH: Speech could not be recognized." << std::endl;
        break;
    case ResultReason::Canceled:
        {
            auto cancellation = CancellationDetails::FromResult(result);
            cout << "CANCELED: Reason=" << (int)cancellation->Reason << std::endl;
    
            if (cancellation->Reason == CancellationReason::Error) {
                cout << "CANCELED: ErrorCode= " << (int)cancellation->ErrorCode << std::endl;
                cout << "CANCELED: ErrorDetails=" << cancellation->ErrorDetails << std::endl;
                cout << "CANCELED: Did you set the speech resource key and region values?" << std::endl;
            }
        }
        break;
    default:
        break;
}

Reconhecimento contínuo

O reconhecimento contínuo é um pouco mais complexo que o pontual. É necessário assinar os eventos Recognizing, Recognized e Canceled para obter os resultados do reconhecimento. Para interromper o reconhecimento, você deve chamar StopContinuousRecognitionAsync. Veja um exemplo de como o reconhecimento contínuo é realizado em um arquivo de entrada de áudio.

Comece definindo a entrada e inicializando SpeechRecognizer:

auto audioConfig = AudioConfig::FromWavFileInput("YourAudioFile.wav");
auto speechRecognizer = SpeechRecognizer::FromConfig(config, audioConfig);

Em seguida, crie uma variável para gerenciar o estado do reconhecimento de fala. Declare promise<void> porque, no início do reconhecimento, você pode presumir com segurança que ele não foi concluído:

promise<void> recognitionEnd;

Em seguida, assine os eventos enviados pelo SpeechRecognizer:

  • Recognizing: sinaliza os eventos que contêm os resultados intermediários de reconhecimento.
  • Recognized: sinaliza os eventos que contêm os resultados finais de reconhecimento, que indicam uma tentativa de reconhecimento bem-sucedida.
  • SessionStopped: sinaliza os eventos que indicam o fim de uma sessão de reconhecimento (operação).
  • Canceled: sinaliza os eventos que contêm os resultados de reconhecimento cancelados. Esses resultados indicam uma tentativa de reconhecimento cancelada como um resultado de uma solicitação de cancelamento direto. Como alternativa, eles indicam uma falha de protocolo ou transporte.
speechRecognizer->Recognizing.Connect([](const SpeechRecognitionEventArgs& e)
    {
        cout << "Recognizing:" << e.Result->Text << std::endl;
    });

speechRecognizer->Recognized.Connect([](const SpeechRecognitionEventArgs& e)
    {
        if (e.Result->Reason == ResultReason::RecognizedSpeech)
        {
            cout << "RECOGNIZED: Text=" << e.Result->Text 
                 << " (text could not be translated)" << std::endl;
        }
        else if (e.Result->Reason == ResultReason::NoMatch)
        {
            cout << "NOMATCH: Speech could not be recognized." << std::endl;
        }
    });

speechRecognizer->Canceled.Connect([&recognitionEnd](const SpeechRecognitionCanceledEventArgs& e)
    {
        cout << "CANCELED: Reason=" << (int)e.Reason << std::endl;
        if (e.Reason == CancellationReason::Error)
        {
            cout << "CANCELED: ErrorCode=" << (int)e.ErrorCode << "\n"
                 << "CANCELED: ErrorDetails=" << e.ErrorDetails << "\n"
                 << "CANCELED: Did you set the speech resource key and region values?" << std::endl;

            recognitionEnd.set_value(); // Notify to stop recognition.
        }
    });

speechRecognizer->SessionStopped.Connect([&recognitionEnd](const SessionEventArgs& e)
    {
        cout << "Session stopped.";
        recognitionEnd.set_value(); // Notify to stop recognition.
    });

Com tudo isso configurado, chame StopContinuousRecognitionAsync para iniciar o reconhecimento:

// Starts continuous recognition. Uses StopContinuousRecognitionAsync() to stop recognition.
speechRecognizer->StartContinuousRecognitionAsync().get();

// Waits for recognition end.
recognitionEnd.get_future().get();

// Stops recognition.
speechRecognizer->StopContinuousRecognitionAsync().get();

Alterar o idioma de origem

Uma tarefa comum no reconhecimento de fala é especificar o idioma da entrada (ou origem). O exemplo a seguir mostra como você pode alterar o idioma de entrada para alemão. No código, encontre a instância de SpeechConfig e adicione esta linha diretamente abaixo dela:

speechConfig->SetSpeechRecognitionLanguage("de-DE");

SetSpeechRecognitionLanguage é um parâmetro que usa uma cadeia de caracteres como argumento. Para obter mais informações, consulte a lista de localidades de conversão de fala em texto com suporte.

Identificação de idioma

Você pode usar a identificação de idioma com o Reconhecimento de conversão de fala em texto quando precisa identificar o idioma em uma fonte de áudio e transcrevê-lo em um texto.

Para obter um exemplo de código completo, consulte Identificação de idioma.

Usar um ponto de extremidade personalizado

Com a fala personalizada, você pode carregar seus próprios dados, testar e treinar um modelo personalizado, comparar a precisão entre modelos e implantar um modelo em um ponto de extremidade personalizado. O exemplo a seguir mostra como definir um ponto de extremidade personalizado.

auto speechConfig = SpeechConfig::FromSubscription("YourSubscriptionKey", "YourServiceRegion");
speechConfig->SetEndpointId("YourEndpointId");
auto speechRecognizer = SpeechRecognizer::FromConfig(speechConfig);

Executar e usar um contêiner

Os contêineres de Fala fornecem APIs de ponto de extremidade de consulta baseadas em websocket que são acessadas através do SDK de Fala e da CLI de Fala. Por padrão, o SDK de Fala e a CLI de Fala usam o serviço público de Fala. Para usar o contêiner, você precisa alterar o método de inicialização. Use uma URL de host de contêiner em vez de chave e região.

Para obter mais informações sobre contêineres, consulte URLs de host em Instalar e executar Contêineres de fala com o Docker.

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

Nesse guia de instruções, você saberá como reconhecer e transcrever fala em texto em tempo real.

Reconhecimento de fala em texto de um microfone

Use o exemplo de código a seguir para executar o reconhecimento de fala por meio do microfone do dispositivo padrão. Substitua as variáveis subscription e region pela sua chave de fala e localização/região, respectivamente. Crie um recurso de Fala no portal do Azure. Para obter mais informações, confira Criar um recurso multisserviço. A execução do script iniciará uma sessão de reconhecimento no microfone padrão e no texto de saída:

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() {
    subscription :=  "YourSpeechKey"
    region := "YourSpeechRegion"

	audioConfig, err := audio.NewAudioConfigFromDefaultMicrophoneInput()
	if err != nil {
		fmt.Println("Got an error: ", err)
		return
	}
	defer audioConfig.Close()
	config, err := speech.NewSpeechConfigFromSubscription(subscription, region)
	if err != nil {
		fmt.Println("Got an error: ", err)
		return
	}
	defer config.Close()
	speechRecognizer, err := speech.NewSpeechRecognizerFromConfig(config, 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')
}

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

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

Agora compile e execute o código:

go build
go run quickstart

Para obter informações detalhadas, confira o conteúdo de referência da classe SpeechConfig e o conteúdo de referência da classe SpeechRecognizer.

Reconhecimento de fala em texto de um arquivo de áudio

Use o exemplo a seguir para executar o reconhecimento de fala de um arquivo de áudio. Substitua as variáveis subscription e region pela sua chave de fala e localização/região, respectivamente. Crie um recurso de Fala no portal do Azure. Para obter mais informações, confira Criar um recurso multisserviço. Além disso, substitua a variável file por um caminho para um arquivo .wav. Quando você executa o script, ele reconhece a fala do arquivo e gera o resultado do texto:

package main

import (
	"fmt"
	"time"

	"github.com/Microsoft/cognitive-services-speech-sdk-go/audio"
	"github.com/Microsoft/cognitive-services-speech-sdk-go/speech"
)

func main() {
    subscription :=  "YourSpeechKey"
    region := "YourSpeechRegion"
    file := "path/to/file.wav"

	audioConfig, err := audio.NewAudioConfigFromWavFileInput(file)
	if err != nil {
		fmt.Println("Got an error: ", err)
		return
	}
	defer audioConfig.Close()
	config, err := speech.NewSpeechConfigFromSubscription(subscription, region)
	if err != nil {
		fmt.Println("Got an error: ", err)
		return
	}
	defer config.Close()
	speechRecognizer, err := speech.NewSpeechRecognizerFromConfig(config, audioConfig)
	if err != nil {
		fmt.Println("Got an error: ", err)
		return
	}
	defer speechRecognizer.Close()
	speechRecognizer.SessionStarted(func(event speech.SessionEventArgs) {
		defer event.Close()
		fmt.Println("Session Started (ID=", event.SessionID, ")")
	})
	speechRecognizer.SessionStopped(func(event speech.SessionEventArgs) {
		defer event.Close()
		fmt.Println("Session Stopped (ID=", event.SessionID, ")")
	})

	task := speechRecognizer.RecognizeOnceAsync()
	var outcome speech.SpeechRecognitionOutcome
	select {
	case outcome = <-task:
	case <-time.After(5 * time.Second):
		fmt.Println("Timed out")
		return
	}
	defer outcome.Close()
	if outcome.Error != nil {
		fmt.Println("Got an error: ", outcome.Error)
	}
	fmt.Println("Got a recognition!")
	fmt.Println(outcome.Result.Text)
}

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

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

Agora compile e execute o código:

go build
go run quickstart

Para obter informações detalhadas, confira o conteúdo de referência da classe SpeechConfig e o conteúdo de referência da classe SpeechRecognizer.

Executar e usar um contêiner

Os contêineres de Fala fornecem APIs de ponto de extremidade de consulta baseadas em websocket que são acessadas através do SDK de Fala e da CLI de Fala. Por padrão, o SDK de Fala e a CLI de Fala usam o serviço público de Fala. Para usar o contêiner, você precisa alterar o método de inicialização. Use uma URL de host de contêiner em vez de chave e região.

Para obter mais informações sobre contêineres, consulte URLs de host em Instalar e executar Contêineres de fala com o Docker.

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

Nesse guia de instruções, você saberá como reconhecer e transcrever fala em texto em tempo real.

Criar uma configuração de Fala

Para chamar o serviço de Fala usando o SDK de Fala, você precisa criar uma instância SpeechConfig. Essa classe inclui informações sobre sua assinatura, como sua chave e localização/região, ponto de extremidade, host ou token de autorização associados.

  1. Crie uma instância de SpeechConfig usando sua chave e localização/região.
  2. Crie um recurso de Fala no portal do Azure. Para obter mais informações, confira Criar um recurso multisserviço.
import com.microsoft.cognitiveservices.speech.*;
import com.microsoft.cognitiveservices.speech.audio.AudioConfig;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class Program {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        SpeechConfig speechConfig = SpeechConfig.fromSubscription("<paste-your-subscription-key>", "<paste-your-region>");
    }
}

Há algumas outras formas de inicializar SpeechConfig:

  • Usar um ponto de extremidade e passe um ponto de extremidade de serviço de Fala. Uma chave ou um token de autorização é opcional.
  • Usar um host e passe um endereço de host. Uma chave ou um token de autorização é opcional.
  • Usar um token de autorização com a região/localização associada.

Observação

Independentemente se você estiver executando o reconhecimento de fala, a síntese de fala, tradução ou reconhecimento de intenção, você sempre criará uma configuração.

Reconhecer fala de um microfone

Para reconhecer uma fala usando o microfone do dispositivo, crie uma instância AudioConfig usando o método fromDefaultMicrophoneInput(). Em seguida, inicialize o objeto SpeechRecognizer passando audioConfig e config.

import com.microsoft.cognitiveservices.speech.*;
import com.microsoft.cognitiveservices.speech.audio.AudioConfig;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class Program {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        SpeechConfig speechConfig = SpeechConfig.fromSubscription("<paste-your-subscription-key>", "<paste-your-region>");
        fromMic(speechConfig);
    }

    public static void fromMic(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 result = task.get();
        System.out.println("RECOGNIZED: Text=" + result.getText());
    }
}

Caso você deseje usar um dispositivo de entrada de áudio específico, especifique a identificação do dispositivo em AudioConfig. Para obter mais informações sobre como selecionar um dispositivo de entrada de áudio, consulte Selecionar um dispositivo de entrada de áudio com o SDK de Fala.

Reconhecer a fala de um arquivo

Caso deseje reconhecer uma fala de um arquivo de áudio em vez de usar um microfone, você ainda precisa criar uma instância de AudioConfig. Mas, nesse caso, você não chama FromDefaultMicrophoneInput(). Você chama fromWavFileInput() e passa o caminho de arquivo:

import com.microsoft.cognitiveservices.speech.*;
import com.microsoft.cognitiveservices.speech.audio.AudioConfig;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class Program {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        SpeechConfig speechConfig = SpeechConfig.fromSubscription("<paste-your-subscription-key>", "<paste-your-region>");
        fromFile(speechConfig);
    }

    public static void fromFile(SpeechConfig speechConfig) throws InterruptedException, ExecutionException {
        AudioConfig audioConfig = AudioConfig.fromWavFileInput("YourAudioFile.wav");
        SpeechRecognizer speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);
        
        Future<SpeechRecognitionResult> task = speechRecognizer.recognizeOnceAsync();
        SpeechRecognitionResult result = task.get();
        System.out.println("RECOGNIZED: Text=" + result.getText());
    }
}

Tratar erros

Os exemplos anteriores apenas obterão o texto reconhecido usando result.getText(). Para tratar erros e outras respostas, escreva um código para processar o resultado. O seguinte exemplo avalia result.getReason() e:

  • Imprime o resultado de reconhecimento: ResultReason.RecognizedSpeech.
  • Se não há correspondência de reconhecimento, ele informa o usuário: ResultReason.NoMatch.
  • Se um erro é encontrado, ele imprime a mensagem de erro: ResultReason.Canceled.
switch (result.getReason()) {
    case ResultReason.RecognizedSpeech:
        System.out.println("We recognized: " + result.getText());
        exitCode = 0;
        break;
    case ResultReason.NoMatch:
        System.out.println("NOMATCH: Speech could not be recognized.");
        break;
    case ResultReason.Canceled: {
            CancellationDetails cancellation = CancellationDetails.fromResult(result);
            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?");
            }
        }
        break;
}

Usar o reconhecimento contínuo

Os exemplos anteriores usam o reconhecimento de captura única, que reconhece uma única expressão. O fim de um único enunciado é determinado pela escuta de silêncio no fim ou até o máximo de 15 segundos de áudio processado.

Por outro lado, o reconhecimento contínuo é usado quando você deseja controlar a interrupção do reconhecimento. É necessário assinar os eventos recognizing, recognized e canceled para obter os resultados do reconhecimento. Para interromper o reconhecimento, chame stopContinuousRecognitionAsync. Veja um exemplo de como o reconhecimento contínuo é realizado em um arquivo de entrada de áudio.

Comece definindo a entrada e inicializando SpeechRecognizer:

AudioConfig audioConfig = AudioConfig.fromWavFileInput("YourAudioFile.wav");
SpeechRecognizer speechRecognizer = new SpeechRecognizer(config, audioConfig);

Em seguida, crie uma variável para gerenciar o estado do reconhecimento de fala. Declare uma instância de Semaphore no escopo da classe:

private static Semaphore stopTranslationWithFileSemaphore;

Em seguida, assine os eventos enviados pelo SpeechRecognizer:

  • recognizing: sinaliza os eventos que contêm os resultados intermediários de reconhecimento.
  • recognized: sinaliza os eventos que contêm os resultados finais de reconhecimento, que indicam uma tentativa de reconhecimento bem-sucedida.
  • sessionStopped: sinaliza os eventos que indicam o fim de uma sessão de reconhecimento (operação).
  • canceled: sinaliza os eventos que contêm os resultados de reconhecimento cancelados. Esses resultados indicam uma tentativa de reconhecimento cancelada como um resultado de uma solicitação de cancelamento direto. Como alternativa, eles indicam uma falha de protocolo ou transporte.
// First initialize the semaphore.
stopTranslationWithFileSemaphore = new Semaphore(0);

speechRecognizer.recognizing.addEventListener((s, e) -> {
    System.out.println("RECOGNIZING: Text=" + e.getResult().getText());
});

speechRecognizer.recognized.addEventListener((s, e) -> {
    if (e.getResult().getReason() == ResultReason.RecognizedSpeech) {
        System.out.println("RECOGNIZED: Text=" + e.getResult().getText());
    }
    else if (e.getResult().getReason() == ResultReason.NoMatch) {
        System.out.println("NOMATCH: Speech could not be recognized.");
    }
});

speechRecognizer.canceled.addEventListener((s, e) -> {
    System.out.println("CANCELED: Reason=" + e.getReason());

    if (e.getReason() == CancellationReason.Error) {
        System.out.println("CANCELED: ErrorCode=" + e.getErrorCode());
        System.out.println("CANCELED: ErrorDetails=" + e.getErrorDetails());
        System.out.println("CANCELED: Did you set the speech resource key and region values?");
    }

    stopTranslationWithFileSemaphore.release();
});

speechRecognizer.sessionStopped.addEventListener((s, e) -> {
    System.out.println("\n    Session stopped event.");
    stopTranslationWithFileSemaphore.release();
});

Com tudo isso configurado, chame startContinuousRecognitionAsync para iniciar o reconhecimento:

// Starts continuous recognition. Uses StopContinuousRecognitionAsync() to stop recognition.
speechRecognizer.startContinuousRecognitionAsync().get();

// Waits for completion.
stopTranslationWithFileSemaphore.acquire();

// Stops recognition.
speechRecognizer.stopContinuousRecognitionAsync().get();

Alterar o idioma de origem

Uma tarefa comum no reconhecimento de fala é especificar o idioma da entrada (ou origem). O exemplo a seguir mostra como você pode alterar o idioma de entrada para francês. No código, encontre a instância SpeechConfig e adicione a linha a seguir diretamente abaixo dela:

config.setSpeechRecognitionLanguage("fr-FR");

setSpeechRecognitionLanguage é um parâmetro que usa uma cadeia de caracteres como argumento. Veja a lista de localidades de conversão de fala em texto com suporte.

Identificação de idioma

Você pode usar a identificação de idioma com o Reconhecimento de conversão de fala em texto quando precisa identificar o idioma em uma fonte de áudio e transcrevê-lo em um texto.

Para obter um exemplo de código completo, consulte Identificação de idioma.

Usar um ponto de extremidade personalizado

Com a fala personalizada, você pode carregar seus próprios dados, testar e treinar um modelo personalizado, comparar a precisão entre modelos e implantar um modelo em um ponto de extremidade personalizado. O exemplo a seguir mostra como definir um ponto de extremidade personalizado:

SpeechConfig speechConfig = SpeechConfig.FromSubscription("YourSubscriptionKey", "YourServiceRegion");
speechConfig.setEndpointId("YourEndpointId");
SpeechRecognizer speechRecognizer = new SpeechRecognizer(speechConfig);

Executar e usar um contêiner

Os contêineres de Fala fornecem APIs de ponto de extremidade de consulta baseadas em websocket que são acessadas através do SDK de Fala e da CLI de Fala. Por padrão, o SDK de Fala e a CLI de Fala usam o serviço público de Fala. Para usar o contêiner, você precisa alterar o método de inicialização. Use uma URL de host de contêiner em vez de chave e região.

Para obter mais informações sobre contêineres, consulte URLs de host em Instalar e executar Contêineres de fala com o Docker.

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

Nesse guia de instruções, você saberá como reconhecer e transcrever fala em texto em tempo real.

Criar uma configuração de Fala

Para chamar o serviço de fala usando o SDK de Fala, você precisa criar uma instância SpeechConfig. Essa classe inclui informações sobre sua assinatura, como sua chave e localização/região, ponto de extremidade, host ou token de autorização associados.

  1. Crie uma instância de SpeechConfig usando sua chave e localização/região.
  2. Crie um recurso de Fala no portal do Azure. Para obter mais informações, confira Criar um recurso multisserviço.
const speechConfig = sdk.SpeechConfig.fromSubscription("YourSpeechKey", "YourSpeechRegion");

Há algumas outras formas de inicializar SpeechConfig:

  • Usar um ponto de extremidade e passe um ponto de extremidade de serviço de Fala. Uma chave ou um token de autorização é opcional.
  • Usar um host e passe um endereço de host. Uma chave ou um token de autorização é opcional.
  • Usar um token de autorização com a região/localização associada.

Observação

Independentemente de se você estiver executando o reconhecimento de fala, a síntese de fala, tradução ou reconhecimento de intenção, você sempre criará uma configuração.

Reconhecer fala de um microfone

Não há suporte no Node.js para o reconhecimento de fala de um microfone. Há suporte apenas em um ambiente JavaScript baseado em navegador. Para obter mais informações, confira o exemplo de React e a implementação de conversão de fala em texto a partir de um microfone no GitHub. O exemplo de React mostra padrões de design para a troca e o gerenciamento de tokens de autenticação. Ele também mostra a captura de áudio de um microfone ou arquivo para conversões de fala em texto.

Observação

Se você quiser usar um dispositivo de entrada de áudio específico, será necessário especificar a ID do dispositivo no objeto AudioConfig. Para obter mais informações, consulte Selecionar um dispositivo de entrada de áudio com o Speech SDK.

Reconhecer a fala de um arquivo

Para reconhecer uma fala de um arquivo de áudio, crie uma instância AudioConfig usando o método fromWavFileInput(), que aceite um objeto Buffer. Em seguida, inicialize SpeechRecognizer transmitindo audioConfig e speechConfig.

const fs = require('fs');
const sdk = require("microsoft-cognitiveservices-speech-sdk");
const speechConfig = sdk.SpeechConfig.fromSubscription("YourSpeechKey", "YourSpeechRegion");

function fromFile() {
    let audioConfig = sdk.AudioConfig.fromWavFileInput(fs.readFileSync("YourAudioFile.wav"));
    let speechRecognizer = new sdk.SpeechRecognizer(speechConfig, audioConfig);

    speechRecognizer.recognizeOnceAsync(result => {
        console.log(`RECOGNIZED: Text=${result.text}`);
        speechRecognizer.close();
    });
}
fromFile();

Reconhecer uma fala de um fluxo na memória

Em muitos casos de uso, seus dados de áudio provavelmente vêm de Armazenamento de Blobs do Azure. Ou, então, eles já estarão na memória como um ArrayBuffer ou uma estrutura de dados brutos semelhante. O seguinte código:

  • Cria um fluxo por push usando createPushStream().
  • Lê um arquivo .wav usando fs.createReadStream para fins de demonstração. Se você já tem dados de áudio no ArrayBuffer, vá diretamente para a gravação do conteúdo no fluxo de entrada.
  • Cria uma configuração de áudio usando o fluxo por push.
const fs = require('fs');
const sdk = require("microsoft-cognitiveservices-speech-sdk");
const speechConfig = sdk.SpeechConfig.fromSubscription("YourSpeechKey", "YourSpeechRegion");

function fromStream() {
    let pushStream = sdk.AudioInputStream.createPushStream();

    fs.createReadStream("YourAudioFile.wav").on('data', function(arrayBuffer) {
        pushStream.write(arrayBuffer.slice());
    }).on('end', function() {
        pushStream.close();
    });
 
    let audioConfig = sdk.AudioConfig.fromStreamInput(pushStream);
    let speechRecognizer = new sdk.SpeechRecognizer(speechConfig, audioConfig);
    speechRecognizer.recognizeOnceAsync(result => {
        console.log(`RECOGNIZED: Text=${result.text}`);
        speechRecognizer.close();
    });
}
fromStream();

Usar um fluxo push como entrada pressupõe que os dados de áudio são dados brutos de modulação por código de pulso (PCM) que ignoram qualquer cabeçalho. A API ainda funcionará em alguns casos se o cabeçalho não tiver sido ignorado. Mas, para os melhores resultados, considere a implementação da lógica para ler os cabeçalhos, de modo que fs comece no início dos dados de áudio.

Tratar erros

Os exemplos anteriores apenas obterão o texto reconhecido da propriedade result.text. Para tratar erros e outras respostas, escreva um código para processar o resultado. O código a seguir avalia a propriedade result.reason e:

  • Imprime o resultado de reconhecimento: ResultReason.RecognizedSpeech.
  • Se não há correspondência de reconhecimento, ele informa o usuário: ResultReason.NoMatch.
  • Se um erro é encontrado, ele imprime a mensagem de erro: ResultReason.Canceled.
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;
    }

Usar o reconhecimento contínuo

Os exemplos anteriores usam o reconhecimento de captura única, que reconhece uma única expressão. O fim de um único enunciado é determinado pela escuta de silêncio no fim ou até o máximo de 15 segundos de áudio processado.

Por outro lado, você pode usar o reconhecimento contínuo quando deseja controlar a interrupção do reconhecimento. É necessário assinar os eventos Recognizing, Recognized e Canceled para obter os resultados do reconhecimento. Para interromper o reconhecimento, chame stopContinuousRecognitionAsync. Veja um exemplo de como o reconhecimento contínuo é realizado em um arquivo de entrada de áudio.

Comece definindo a entrada e inicializando SpeechRecognizer:

const speechRecognizer = new sdk.SpeechRecognizer(speechConfig, audioConfig);

Em seguida, assine os eventos enviados pelo SpeechRecognizer:

  • recognizing: sinaliza os eventos que contêm os resultados intermediários de reconhecimento.
  • recognized: sinaliza os eventos que contêm os resultados finais de reconhecimento, que indicam uma tentativa de reconhecimento bem-sucedida.
  • sessionStopped: sinaliza os eventos que indicam o fim de uma sessão de reconhecimento (operação).
  • canceled: sinaliza os eventos que contêm os resultados de reconhecimento cancelados. Esses resultados indicam uma tentativa de reconhecimento cancelada como um resultado de uma solicitação de cancelamento direto. Como alternativa, eles indicam uma falha de protocolo ou transporte.
speechRecognizer.recognizing = (s, e) => {
    console.log(`RECOGNIZING: Text=${e.result.text}`);
};

speechRecognizer.recognized = (s, e) => {
    if (e.result.reason == sdk.ResultReason.RecognizedSpeech) {
        console.log(`RECOGNIZED: Text=${e.result.text}`);
    }
    else if (e.result.reason == sdk.ResultReason.NoMatch) {
        console.log("NOMATCH: Speech could not be recognized.");
    }
};

speechRecognizer.canceled = (s, e) => {
    console.log(`CANCELED: Reason=${e.reason}`);

    if (e.reason == sdk.CancellationReason.Error) {
        console.log(`"CANCELED: ErrorCode=${e.errorCode}`);
        console.log(`"CANCELED: ErrorDetails=${e.errorDetails}`);
        console.log("CANCELED: Did you set the speech resource key and region values?");
    }

    speechRecognizer.stopContinuousRecognitionAsync();
};

speechRecognizer.sessionStopped = (s, e) => {
    console.log("\n    Session stopped event.");
    speechRecognizer.stopContinuousRecognitionAsync();
};

Com tudo isso configurado, chame startContinuousRecognitionAsync para iniciar o reconhecimento:

speechRecognizer.startContinuousRecognitionAsync();

// Make the following call at some point to stop recognition:
// speechRecognizer.stopContinuousRecognitionAsync();

Alterar o idioma de origem

Uma tarefa comum no reconhecimento de fala é especificar o idioma da entrada (ou origem). O exemplo a seguir mostra como você pode alterar o idioma de entrada para Italiano. No código, encontre a instância de SpeechConfig e adicione esta linha diretamente abaixo dela:

speechConfig.speechRecognitionLanguage = "it-IT";

A propriedade speechRecognitionLanguage espera uma cadeia de caracteres em formato idioma-localidade. Para obter mais informações, consulte a lista de localidades de conversão de fala em texto com suporte.

Identificação de idioma

Você pode usar a identificação de idioma com o Reconhecimento de conversão de fala em texto quando precisa identificar o idioma em uma fonte de áudio e transcrevê-lo em um texto.

Para obter um exemplo de código completo, consulte Identificação de idioma.

Usar um ponto de extremidade personalizado

Com a fala personalizada, você pode carregar seus próprios dados, testar e treinar um modelo personalizado, comparar a precisão entre modelos e implantar um modelo em um ponto de extremidade personalizado. O exemplo a seguir mostra como definir um ponto de extremidade personalizado.

var speechConfig = SpeechSDK.SpeechConfig.fromSubscription("YourSubscriptionKey", "YourServiceRegion");
speechConfig.endpointId = "YourEndpointId";
var speechRecognizer = new SpeechSDK.SpeechRecognizer(speechConfig);

Executar e usar um contêiner

Os contêineres de Fala fornecem APIs de ponto de extremidade de consulta baseadas em websocket que são acessadas através do SDK de Fala e da CLI de Fala. Por padrão, o SDK de Fala e a CLI de Fala usam o serviço público de Fala. Para usar o contêiner, você precisa alterar o método de inicialização. Use uma URL de host de contêiner em vez de chave e região.

Para obter mais informações sobre contêineres, consulte URLs de host em Instalar e executar Contêineres de fala com o Docker.

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

Nesse guia de instruções, você saberá como reconhecer e transcrever fala em texto em tempo real.

Instalar o SDK de Fala e exemplos

O repositório Azure-Samples/cognitive-services-speech-sdk contém exemplos escritos em Objective-C para iOS e Mac. Selecione um link para ver as instruções de instalação de cada exemplo:

Para obter mais informações, consulte a referência do SDK de Fala para Objective-C.

Usar um ponto de extremidade personalizado

Com a fala personalizada, você pode carregar seus próprios dados, testar e treinar um modelo personalizado, comparar a precisão entre modelos e implantar um modelo em um ponto de extremidade personalizado. O exemplo a seguir mostra como definir um ponto de extremidade personalizado:

SPXSpeechConfiguration *speechConfig = [[SPXSpeechConfiguration alloc] initWithSubscription:"YourSubscriptionKey" region:"YourServiceRegion"];
speechConfig.endpointId = "YourEndpointId";
SPXSpeechRecognizer* speechRecognizer = [[SPXSpeechRecognizer alloc] init:speechConfig];

Executar e usar um contêiner

Os contêineres de Fala fornecem APIs de ponto de extremidade de consulta baseadas em websocket que são acessadas através do SDK de Fala e da CLI de Fala. Por padrão, o SDK de Fala e a CLI de Fala usam o serviço público de Fala. Para usar o contêiner, você precisa alterar o método de inicialização. Use uma URL de host de contêiner em vez de chave e região.

Para obter mais informações sobre contêineres, consulte URLs de host em Instalar e executar Contêineres de fala com o Docker.

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

Nesse guia de instruções, você saberá como reconhecer e transcrever fala em texto em tempo real.

Instalar o SDK de Fala e exemplos

O repositório Azure-Samples/cognitive-services-speech-sdk contém exemplos escritos em Swift para iOS e Mac. Selecione um link para ver as instruções de instalação de cada exemplo:

Para obter mais informações, consulte a referência do SDK de Fala para Swift.

Usar um ponto de extremidade personalizado

Com a fala personalizada, você pode carregar seus próprios dados, testar e treinar um modelo personalizado, comparar a precisão entre modelos e implantar um modelo em um ponto de extremidade personalizado. O exemplo a seguir mostra como definir um ponto de extremidade personalizado:

let speechConfig = SPXSpeechConfiguration(subscription: "YourSubscriptionKey", region: "YourServiceRegion");
speechConfig.endpointId = "YourEndpointId";
let speechRecognizer = SPXSpeechRecognizer(speechConfiguration: speechConfig);

Executar e usar um contêiner

Os contêineres de Fala fornecem APIs de ponto de extremidade de consulta baseadas em websocket que são acessadas através do SDK de Fala e da CLI de Fala. Por padrão, o SDK de Fala e a CLI de Fala usam o serviço público de Fala. Para usar o contêiner, você precisa alterar o método de inicialização. Use uma URL de host de contêiner em vez de chave e região.

Para obter mais informações sobre contêineres, consulte URLs de host em Instalar e executar Contêineres de fala com o Docker.

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

Nesse guia de instruções, você saberá como reconhecer e transcrever fala em texto em tempo real.

Criar uma configuração de Fala

Para chamar o serviço de Fala usando o SDK de Fala, você precisa criar uma instância SpeechConfig. Essa classe inclui informações sobre sua assinatura, como chave de fala e localização/região, ponto de extremidade, host ou token de autorização associados.

  1. Crie uma instância de SpeechConfig usando sua chave de fala e localização/região.
  2. Crie um recurso de Fala no portal do Azure. Para obter mais informações, confira Criar um recurso multisserviço.
speech_config = speechsdk.SpeechConfig(subscription="YourSpeechKey", region="YourSpeechRegion")

Há algumas outras formas de inicializar SpeechConfig:

  • Usar um ponto de extremidade e passe um ponto de extremidade de serviço de Fala. É opcional ter uma chave de fala ou um token de autorização.
  • Usar um host e passe um endereço de host. É opcional ter uma chave de fala ou um token de autorização.
  • Usar um token de autorização com a região/localização associada.

Observação

Independentemente de se você estiver executando o reconhecimento de fala, a síntese de fala, tradução ou reconhecimento de intenção, você sempre criará uma configuração.

Reconhecer fala de um microfone

Para reconhecer a fala usando o microfone do dispositivo, crie uma instância de SpeechRecognizer sem transmitir AudioConfig e transmita speech_config:

import azure.cognitiveservices.speech as speechsdk

def from_mic():
    speech_config = speechsdk.SpeechConfig(subscription="YourSpeechKey", region="YourSpeechRegion")
    speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config)

    print("Speak into your microphone.")
    result = speech_recognizer.recognize_once_async().get()
    print(result.text)

from_mic()

Caso você deseje usar um dispositivo de entrada de áudio específico, especifique a identificação do dispositivo em AudioConfig e a transmita para o parâmetro audio_config do construtor SpeechRecognizer. Para obter mais informações sobre como selecionar um dispositivo de entrada de áudio, consulte Selecionar um dispositivo de entrada de áudio com o SDK de Fala

Reconhecer a fala de um arquivo

Se quiser reconhecer uma fala de um arquivo de áudio em vez de usar um microfone, crie uma instância de AudioConfig e use o parâmetro filename:

import azure.cognitiveservices.speech as speechsdk

def from_file():
    speech_config = speechsdk.SpeechConfig(subscription="YourSpeechKey", region="YourSpeechRegion")
    audio_config = speechsdk.AudioConfig(filename="your_file_name.wav")
    speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config, audio_config=audio_config)

    result = speech_recognizer.recognize_once_async().get()
    print(result.text)

from_file()

Tratar erros

Os exemplos anteriores apenas obterão o texto reconhecido da propriedade result.text. Para tratar erros e outras respostas, escreva um código para processar o resultado. O código a seguir avalia a propriedade result.reason e:

  • Imprime o resultado de reconhecimento: speechsdk.ResultReason.RecognizedSpeech.
  • Se não há correspondência de reconhecimento, ele informa o usuário: speechsdk.ResultReason.NoMatch.
  • Se um erro é encontrado, ele imprime a mensagem de erro: speechsdk.ResultReason.Canceled.
if result.reason == speechsdk.ResultReason.RecognizedSpeech:
    print("Recognized: {}".format(result.text))
elif result.reason == speechsdk.ResultReason.NoMatch:
    print("No speech could be recognized: {}".format(result.no_match_details))
elif result.reason == speechsdk.ResultReason.Canceled:
    cancellation_details = 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?")

Usar o reconhecimento contínuo

Os exemplos anteriores usam o reconhecimento de captura única, que reconhece uma única expressão. O fim de um único enunciado é determinado pela escuta de silêncio no fim ou até o máximo de 15 segundos de áudio processado.

Por outro lado, o reconhecimento contínuo é usado quando você deseja controlar a interrupção do reconhecimento. Ele exige que você se conecte ao EventSignal para obter os resultados de reconhecimento. Para interromper o reconhecimento, chame stop_continuous_recognition () ou stop_continuous_recognition (). Veja um exemplo de como o reconhecimento contínuo é realizado em um arquivo de entrada de áudio.

Comece definindo a entrada e inicializando SpeechRecognizer:

audio_config = speechsdk.audio.AudioConfig(filename=weatherfilename)
speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config, audio_config=audio_config)

Em seguida, crie uma variável para gerenciar o estado do reconhecimento de fala. Defina a variável como False porque, no início do reconhecimento, você pode pressupor com segurança que ela não foi concluída:

done = False

Agora, crie um retorno de chamada para interromper o reconhecimento contínuo quando evt for recebido. Tenha estes pontos em mente:

  • Quando evt é recebido, a mensagem evt é impressa.
  • Depois que evt for recebido, evt será chamado para interromper o reconhecimento.
  • O estado de reconhecimento é alterado para True.
def stop_cb(evt):
    print('CLOSING on {}'.format(evt))
    speech_recognizer.stop_continuous_recognition()
    nonlocal done
    done = True

O exemplo de código a seguir mostra como conectar retornos de chamada a eventos enviados do SpeechRecognizer. Os eventos são:

  • recognizing: sinaliza os eventos que contêm os resultados intermediários de reconhecimento.
  • recognized: sinaliza os eventos que contêm os resultados finais de reconhecimento, que indicam uma tentativa de reconhecimento bem-sucedida.
  • session_started: sinaliza os eventos que indicam o início de uma sessão de reconhecimento (operação).
  • session_stopped: sinaliza os eventos que indicam o fim de uma sessão de reconhecimento (operação).
  • canceled: sinaliza os eventos que contêm os resultados de reconhecimento cancelados. Esses resultados indicam uma tentativa de reconhecimento cancelada como um resultado de uma solicitação de cancelamento direto. Como alternativa, eles indicam uma falha de protocolo ou transporte.
speech_recognizer.recognizing.connect(lambda evt: print('RECOGNIZING: {}'.format(evt)))
speech_recognizer.recognized.connect(lambda evt: print('RECOGNIZED: {}'.format(evt)))
speech_recognizer.session_started.connect(lambda evt: print('SESSION STARTED: {}'.format(evt)))
speech_recognizer.session_stopped.connect(lambda evt: print('SESSION STOPPED {}'.format(evt)))
speech_recognizer.canceled.connect(lambda evt: print('CANCELED {}'.format(evt)))

speech_recognizer.session_stopped.connect(stop_cb)
speech_recognizer.canceled.connect(stop_cb)

Com tudo isso configurado, chame start_continuous_recognition():

speech_recognizer.start_continuous_recognition()
while not done:
    time.sleep(.5)

Alterar o idioma de origem

Uma tarefa comum no reconhecimento de fala é especificar o idioma da entrada (ou origem). O exemplo a seguir mostra como você pode alterar o idioma de entrada para alemão. No código, encontre a instância de SpeechConfig e adicione esta linha diretamente abaixo dela:

speech_config.speech_recognition_language="de-DE"

speech_recognition_language é um parâmetro que usa uma cadeia de caracteres como argumento. Para obter mais informações, consulte a lista de localidades de conversão de fala em texto com suporte.

Identificação de idioma

Você pode usar a identificação de idioma com o Reconhecimento de conversão de fala em texto quando precisa identificar o idioma em uma fonte de áudio e transcrevê-lo em um texto.

Para obter um exemplo de código completo, consulte Identificação de idioma.

Usar um ponto de extremidade personalizado

Com a fala personalizada, você pode carregar seus próprios dados, testar e treinar um modelo personalizado, comparar a precisão entre modelos e implantar um modelo em um ponto de extremidade personalizado. O exemplo a seguir mostra como definir um ponto de extremidade personalizado.

speech_config = speechsdk.SpeechConfig(subscription="YourSubscriptionKey", region="YourServiceRegion")
speech_config.endpoint_id = "YourEndpointId"
speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config)

Executar e usar um contêiner

Os contêineres de Fala fornecem APIs de ponto de extremidade de consulta baseadas em websocket que são acessadas através do SDK de Fala e da CLI de Fala. Por padrão, o SDK de Fala e a CLI de Fala usam o serviço público de Fala. Para usar o contêiner, você precisa alterar o método de inicialização. Use uma URL de host de contêiner em vez de chave e região.

Para obter mais informações sobre contêineres, consulte URLs de host em Instalar e executar Contêineres de fala com o Docker.

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

Nesse guia de instruções, você saberá como reconhecer e transcrever fala em texto em tempo real.

Conversão de fala em texto

No prompt de comando, execute o comando a seguir. Insira os seguintes valores no comando:

  • Sua chave de assinatura do serviço de Fala.
  • Sua região do serviço de Fala.
  • O caminho para os arquivos de entrada de áudio. É possível gerar arquivos de áudio usando a conversão de texto em fala.
curl --location --request POST 'https://INSERT_REGION_HERE.stt.speech.microsoft.com/speech/recognition/conversation/cognitiveservices/v1?language=en-US' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: audio/wav' \
--data-binary @'INSERT_AUDIO_FILE_PATH_HERE'

Você deverá receber uma resposta com um corpo JSON semelhante à mostrada a seguir:

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

Para obter mais informações, confira a Referência da API REST de conversão de fala em texto.

Nesse guia de instruções, você saberá como reconhecer e transcrever fala em texto em tempo real.

Reconhecer fala de um microfone

Conecte e ligue o microfone do seu PC. Desative todos os aplicativos que também possam usar o microfone. Alguns computadores têm um microfone interno, enquanto outros exigem a configuração de um dispositivo Bluetooth.

Agora você está pronto para executar a CLI de Fala para reconhecer a fala do microfone. Na linha de comando, altere para o diretório que contém o arquivo binário da CLI de Fala. Em seguida, execute o seguinte comando:

spx recognize --microphone

Observação

A CLI de Fala usa o inglês como padrão. Você pode escolher um idioma diferente na tabela da conversão de fala em texto. Por exemplo, adicione --source de-DE para reconhecer a fala em alemão.

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 ou quando você seleciona Ctrl+C.

Reconhecer a fala de um arquivo

A CLI de Fala pode reconhecer a fala em muitos formatos de arquivo e idiomas naturais. Nesse exemplo, você pode usar um arquivo .wav (16 KHz ou 8 KHz, de 16 bits e PCM mono) que contenha uma fala em inglês. Ou, se quiser um exemplo rápido, baixe o arquivo whatstheweatherlike.wav e copie-o para o mesmo diretório que o arquivo binário da CLI de Fala.

Use o seguinte comando para executar a CLI de Fala a fim de reconhecer a fala encontrada no arquivo de áudio:

spx recognize --file whatstheweatherlike.wav

Observação

A CLI de Fala usa o inglês como padrão. Você pode escolher um idioma diferente na tabela da conversão de fala em texto. Por exemplo, adicione --source de-DE para reconhecer a fala em alemão.

A CLI de Fala mostrará uma transcrição de texto da fala na tela.

Executar e usar um contêiner

Os contêineres de Fala fornecem APIs de ponto de extremidade de consulta baseadas em websocket que são acessadas através do SDK de Fala e da CLI de Fala. Por padrão, o SDK de Fala e a CLI de Fala usam o serviço público de Fala. Para usar o contêiner, você precisa alterar o método de inicialização. Use uma URL de host de contêiner em vez de chave e região.

Para obter mais informações sobre contêineres, consulte URLs de host em Instalar e executar Contêineres de fala com o Docker.

Próximas etapas