How to recognize speech (Como reconhecer voz)

  • Artigo

Pacote de documentação | de referência (NuGet) | Exemplos adicionais no GitHub

Neste guia de instruções, você aprende a reconhecer e transcrever fala para 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 SpeechConfig instância. Essa classe inclui informações sobre sua assinatura, como sua chave e local/região associada, ponto de extremidade, host ou token de autorização.

  1. Crie uma SpeechConfig instância usando sua chave e local/região.
  2. Crie um recurso de Fala no portal do Azure. Para obter mais informações, consulte 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");
    }
}

Você pode inicializar SpeechConfig de algumas outras maneiras:

  • Use um ponto de extremidade e passe um ponto de extremidade do serviço de Fala. Uma chave ou token de autorização é opcional.
  • Use um host e passe um endereço de host. Uma chave ou token de autorização é opcional.
  • Use um token de autorização com a região/local associado.

Nota

Independentemente de estar executando reconhecimento de fala, síntese de fala, tradução ou reconhecimento de intenção, você sempre cria uma configuração.

Reconhecer voz a partir de um microfone

Para reconhecer a fala usando o microfone do dispositivo, crie uma AudioConfig ocorrência usando o FromDefaultMicrophoneInput() método. Em seguida, inicialize o SpeechRecognizer objeto 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);
    }
}

Se você quiser usar um dispositivo de entrada de áudio específico , precisará especificar o ID do dispositivo em AudioConfig. Saiba como obter o ID do dispositivo para o seu dispositivo de entrada de áudio.

Reconhecer a voz a partir de um ficheiro

Se você quiser reconhecer a fala de um arquivo de áudio em vez de um microfone, ainda precisará criar uma AudioConfig instância. Mas para este caso você não liga FromDefaultMicrophoneInput(). Você chama FromWavFileInput() e passa o caminho do 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 fala a partir de um fluxo na memória

Para muitos casos de uso, é provável que seus dados de áudio venham do Armazenamento de Blobs do Azure ou, caso contrário, já estejam na memória como uma byte[] instância 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ída. O código de exemplo executa as seguintes ações:

  • Grava dados de áudio brutos (PCM) PushAudioInputStream usando a Write() função, que aceita uma byte[] instância.
  • Lê um arquivo .wav usando FileReader para fins de demonstração. Se você já tiver dados de áudio em uma byte[] instância, poderá pular diretamente para gravar o conteúdo no fluxo de entrada.
  • O formato padrão é 16-bit, 16-KHz mono pulse-code modulation (PCM) dados. Para personalizar o formato, você pode passar um AudioStreamFormat objeto para CreatePushStream() usando a função AudioStreamFormat.GetWaveFormatPCM(sampleRate, (byte)bitRate, (byte)channels)estática .
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 push como entrada pressupõe que os dados de áudio são um PCM bruto e ignora quaisquer cabeçalhos. A API ainda funciona em certos casos se o cabeçalho não tiver sido ignorado. Para obter os melhores resultados, considere a implementação de lógica para ler os cabeçalhos de modo que byte[] comece no início dos dados de áudio.

Processar erros

Os exemplos anteriores obtêm apenas o texto reconhecido da result.Text propriedade. Para lidar com erros e outras respostas, você precisa escrever algum código para lidar com o resultado. O código a seguir avalia a result.Reason propriedade e:

  • Imprime o resultado do reconhecimento: ResultReason.RecognizedSpeech.
  • Se não houver correspondência de reconhecimento, ele informa ao usuário: ResultReason.NoMatch.
  • Se for encontrado um erro, 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;
}

Use o reconhecimento contínuo

Os exemplos anteriores usam o reconhecimento de tiro único, que reconhece um único enunciado. O fim de um único enunciado é determinado pela escuta do silêncio no final ou até que um máximo de 15 segundos de áudio seja processado.

Por outro lado, você usa o reconhecimento contínuo quando deseja controlar quando parar de reconhecer. Ele requer que você se inscreva no Recognizing, Recognizede Canceled eventos para obter os resultados de reconhecimento. Para interromper o reconhecimento, você deve ligar para StopContinuousRecognitionAsync. Aqui está 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);

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

var stopRecognition = new TaskCompletionSource<int>();

Em seguida, inscreva-se nos eventos enviados SpeechRecognizer :

  • Recognizing: Sinal para eventos que contêm resultados de reconhecimento intermediários.
  • Recognized: Sinal para eventos que contêm resultados finais de reconhecimento, que indicam uma tentativa de reconhecimento bem-sucedida.
  • SessionStopped: Sinal para eventos que indicam o fim de uma sessão de reconhecimento (operação).
  • Canceled: Sinal para eventos que contêm resultados de reconhecimento cancelados. Esses resultados indicam uma tentativa de reconhecimento que foi cancelada como resultado de uma solicitação de cancelamento direto. Como alternativa, indicam uma falha de transporte ou protocolo.
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 configurado, ligue StartContinuousRecognitionAsync para começar a reconhecer:

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 partida

Uma tarefa comum para o reconhecimento de fala é especificar o idioma de entrada (ou fonte). O exemplo a seguir mostra como alterar o idioma de entrada para italiano. Em seu código, localize sua SpeechConfig instância e adicione esta linha diretamente abaixo dela:

speechConfig.SpeechRecognitionLanguage = "it-IT";

A SpeechRecognitionLanguage propriedade espera uma cadeia de caracteres de formato de localidade de idioma. Para obter mais informações, consulte a lista de localidades de fala para texto suportadas.

Identificação linguística

Você pode usar a identificação de idioma com fala para reconhecimento de texto quando precisar identificar o idioma em uma fonte de áudio e, em seguida, transcrevê-lo para 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 por meio 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 de Fala público. 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 se espera 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 manuseamento do silêncio incluem:

  • Fala rápida encadeando 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 de tiro único terminando muito rapidamente enquanto espera que a fala comece.

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

  • O tempo limite de silêncio de segmentação ajusta a quantidade de áudio não falado permitida dentro de uma frase que está sendo falada 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 definidas muito altas.
    • Valores mais baixos geralmente tornam os resultados mais curtos e garantem quebras mais rápidas e frequentes entre frases, mas também podem fazer com que frases individuais se separem em vários resultados quando definidas muito baixas.
    • Esse tempo limite pode ser definido como valores inteiros entre 100 e 5000, em milissegundos, com 500 como padrão típico.
  • O tempo limite de silêncio inicial ajusta a quantidade de áudio não falado permitida antes de uma frase antes que a tentativa de reconhecimento termine em um resultado "sem correspondência".
    • Valores mais elevados dão aos oradores mais tempo para reagir e começar a falar, mas também podem resultar numa resposta lenta quando nada é falado.
    • Valores mais baixos garantem um prompt "sem correspondência" para uma experiência de usuário mais rápida e um manuseio de áudio mais controlado, mas podem cortar um alto-falante 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" chegam, mas não afeta o conteúdo dos resultados de reconhecimento.
    • Esse tempo limite pode ser definido como qualquer valor inteiro não negativo, em milissegundos, ou definido como 0 para desativá-lo completamente. 5000 é um padrão típico para reconhecimento de captura única, enquanto 15000 é um padrão típico para reconhecimento contínuo.

Como há compensações ao modificar esses tempos limites, você só deve alterar as configurações quando tiver um problema relacionado ao tratamento do silêncio. Os valores padrão lidam perfeitamente com a maioria dos áudios falados e apenas cenários incomuns devem encontrar problemas.

Exemplo: Os usuários que falam um número de série como "ABC-123-4567" podem pausar entre grupos de caracteres por tempo suficiente para que o número de série seja dividido em vários resultados. Neste 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 gravado pode ser rápida o suficiente para que várias frases seguidas sejam combinadas, com grandes resultados de reconhecimento chegando apenas uma ou duas vezes por minuto. Nesse caso, defina o tempo limite de silêncio da segmentação para um valor mais baixo, como 300 ms:

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

Exemplo: Um reconhecimento de disparo único que pede a um orador para encontrar e ler um número de série termina demasiado depressa enquanto o número está a ser encontrado. Neste caso, tente um tempo limite de silêncio inicial mais longo, como 10.000 ms:

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

Pacote de documentação | de referência (NuGet) | Exemplos adicionais no GitHub

Neste guia de instruções, você aprende a reconhecer e transcrever fala para 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 SpeechConfig instância. Essa classe inclui informações sobre sua assinatura, como sua chave e local/região associada, ponto de extremidade, host ou token de autorização.

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

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

Você pode inicializar SpeechConfig de algumas outras maneiras:

  • Use um ponto de extremidade e passe um ponto de extremidade do serviço de Fala. Uma chave ou token de autorização é opcional.
  • Use um host e passe um endereço de host. Uma chave ou token de autorização é opcional.
  • Use um token de autorização com a região/local associado.

Nota

Independentemente de estar executando reconhecimento de fala, síntese de fala, tradução ou reconhecimento de intenção, você sempre cria uma configuração.

Reconhecer voz a partir de um microfone

Para reconhecer a fala usando o microfone do dispositivo, crie uma AudioConfig ocorrência usando a FromDefaultMicrophoneInput() função de membro. Em seguida, inicialize oSpeechRecognizer objeto 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;

Se você quiser usar um dispositivo de entrada de áudio específico , precisará especificar o ID do dispositivo em AudioConfig. Para obter mais informações sobre como obter a ID do dispositivo para o dispositivo de entrada de áudio, consulte Selecionar um dispositivo de entrada de áudio com o SDK de fala

Reconhecer a voz a partir de um ficheiro

Se você quiser reconhecer a fala de um arquivo de áudio em vez de usar um microfone, ainda precisará criar uma AudioConfig instância. Mas para este caso você não liga FromDefaultMicrophoneInput(). Você chama FromWavFileInput() e passa o caminho do 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 fala usando a classe Recognizer

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

Reconhecimento de tiro único

O reconhecimento de disparo único reconhece de forma assíncrona um único enunciado. O fim de um único enunciado é determinado pela escuta do silêncio no final ou até que um máximo de 15 segundos de áudio seja processado. Eis um exemplo de reconhecimento assíncrono de disparo único através RecognizeOnceAsyncde:

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

Você precisa escrever algum código para lidar com o resultado. Esta amostra avalia result->Reason e:

  • Imprime o resultado do reconhecimento: ResultReason::RecognizedSpeech.
  • Se não houver correspondência de reconhecimento, ele informa ao usuário: ResultReason::NoMatch.
  • Se for encontrado um erro, 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 envolvido do que o reconhecimento de uma única tacada. Ele requer que você se inscreva no Recognizing, Recognizede Canceled eventos para obter os resultados de reconhecimento. Para interromper o reconhecimento, você deve chamar StopContinuousRecognitionAsync. Aqui está 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 terminou:

promise<void> recognitionEnd;

Em seguida, inscreva-se nos eventos enviados SpeechRecognizer :

  • Recognizing: Sinal para eventos que contêm resultados de reconhecimento intermediários.
  • Recognized: Sinal para eventos que contêm resultados finais de reconhecimento, que indicam uma tentativa de reconhecimento bem-sucedida.
  • SessionStopped: Sinal para eventos que indicam o fim de uma sessão de reconhecimento (operação).
  • Canceled: Sinal para eventos que contêm resultados de reconhecimento cancelados. Esses resultados indicam uma tentativa de reconhecimento que foi cancelada como resultado de uma solicitação de cancelamento direto. Como alternativa, indicam uma falha de transporte ou protocolo.
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 configurado, ligue StopContinuousRecognitionAsync para começar a reconhecer:

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

Uma tarefa comum para o reconhecimento de fala é especificar o idioma de entrada (ou fonte). O exemplo a seguir mostra como alterar o idioma de entrada para alemão. Em seu código, localize sua SpeechConfig instância 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 fala para texto suportadas.

Identificação linguística

Você pode usar a identificação de idioma com fala para reconhecimento de texto quando precisar identificar o idioma em uma fonte de áudio e, em seguida, transcrevê-lo para 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 por meio 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 de Fala público. 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.

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

Neste guia de instruções, você aprende a reconhecer e transcrever fala para texto em tempo real.

Reconhecer fala em texto a partir de um microfone

Use o exemplo de código a seguir para executar o reconhecimento de fala a partir do microfone padrão do dispositivo. Substitua as variáveis subscription e region pela sua chave de fala e localização/região, respetivamente. Crie um recurso de Fala no portal do Azure. Para obter mais informações, consulte Criar um recurso multisserviço. A execução do script inicia 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 seguintes comandos para criar um arquivo go.mod vinculado a 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, consulte o conteúdo de referência para a SpeechConfig classe e o conteúdo de referência para a SpeechRecognizer classe.

Reconhecer fala em texto a partir de um arquivo de áudio

Use o exemplo a seguir para executar o reconhecimento de fala a partir de um arquivo de áudio. Substitua as variáveis subscription e region pela sua chave de fala e localização/região, respetivamente. Crie um recurso de Fala no portal do Azure. Para obter mais informações, consulte 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 produz 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 seguintes comandos para criar um arquivo go.mod vinculado a 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, consulte o conteúdo de referência para a SpeechConfig classe e o conteúdo de referência para a SpeechRecognizer classe.

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 por meio 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 de Fala público. 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

Neste guia de instruções, você aprende a reconhecer e transcrever fala para 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 de SpeechConfig . Essa classe inclui informações sobre sua assinatura, como sua chave e local/região associada, ponto de extremidade, host ou token de autorização.

  1. Crie uma SpeechConfig instância usando sua chave e local/região.
  2. Crie um recurso de Fala no portal do Azure. Para obter mais informações, consulte 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>");
    }
}

Você pode inicializar SpeechConfig de algumas outras maneiras:

  • Use um ponto de extremidade e passe um ponto de extremidade do serviço de Fala. Uma chave ou token de autorização é opcional.
  • Use um host e passe um endereço de host. Uma chave ou token de autorização é opcional.
  • Use um token de autorização com a região/local associado.

Nota

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

Reconhecer voz a partir de um microfone

Para reconhecer a fala usando o microfone do dispositivo, crie uma AudioConfig ocorrência usando o fromDefaultMicrophoneInput() método. Em seguida, inicialize o SpeechRecognizer objeto 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());
    }
}

Se você quiser usar um dispositivo de entrada de áudio específico , precisará especificar o ID do dispositivo em AudioConfig. Para obter mais informações sobre como obter a ID do dispositivo para o dispositivo de entrada de áudio, consulte Selecionar um dispositivo de entrada de áudio com o SDK de fala.

Reconhecer a voz a partir de um ficheiro

Se você quiser reconhecer a fala de um arquivo de áudio em vez de usar um microfone, ainda precisará criar uma AudioConfig instância. Mas para este caso você não liga FromDefaultMicrophoneInput(). Você chama fromWavFileInput() e passa o caminho do 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());
    }
}

Processar erros

Os exemplos anteriores obtêm apenas o texto reconhecido usando result.getText(). Para lidar com erros e outras respostas, você precisa escrever algum código para lidar com o resultado. O exemplo a seguir avalia result.getReason() e:

  • Imprime o resultado do reconhecimento: ResultReason.RecognizedSpeech.
  • Se não houver correspondência de reconhecimento, ele informa ao usuário: ResultReason.NoMatch.
  • Se for encontrado um erro, 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;
}

Use o reconhecimento contínuo

Os exemplos anteriores usam o reconhecimento de tiro único, que reconhece um único enunciado. O fim de um único enunciado é determinado pela escuta do silêncio no final ou até que um máximo de 15 segundos de áudio seja processado.

Por outro lado, você usa o reconhecimento contínuo quando deseja controlar quando parar de reconhecer. Ele requer que você se inscreva no recognizing, recognizede canceled eventos para obter os resultados de reconhecimento. Para interromper o reconhecimento, você deve ligar para stopContinuousRecognitionAsync. Aqui está um exemplo de como você pode executar o reconhecimento contínuo 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 Semaphore instância no escopo da classe:

private static Semaphore stopTranslationWithFileSemaphore;

Em seguida, inscreva-se nos eventos enviados SpeechRecognizer :

  • recognizing: Sinal para eventos que contêm resultados de reconhecimento intermediários.
  • recognized: Sinal para eventos que contêm resultados finais de reconhecimento, que indicam uma tentativa de reconhecimento bem-sucedida.
  • sessionStopped: Sinal para eventos que indicam o fim de uma sessão de reconhecimento (operação).
  • canceled: Sinal para eventos que contêm resultados de reconhecimento cancelados. Esses resultados indicam uma tentativa de reconhecimento que foi cancelada como resultado de uma solicitação de cancelamento direto. Como alternativa, indicam uma falha de transporte ou protocolo.
// 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 configurado, ligue startContinuousRecognitionAsync para começar a reconhecer:

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

Uma tarefa comum para o reconhecimento de fala é especificar o idioma de entrada (ou fonte). O exemplo a seguir mostra como alterar o idioma de entrada para francês. Em seu código, localize sua SpeechConfig instância e adicione esta linha diretamente abaixo dela:

config.setSpeechRecognitionLanguage("fr-FR");

setSpeechRecognitionLanguage é um parâmetro que usa uma cadeia de caracteres como argumento. Consulte a lista de localidades de fala para texto suportadas.

Identificação linguística

Você pode usar a identificação de idioma com fala para reconhecimento de texto quando precisar identificar o idioma em uma fonte de áudio e, em seguida, transcrevê-lo para 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 por meio 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 de Fala público. 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.

Pacote de documentação | de referência (npm) | Exemplos adicionais no código-fonte da Biblioteca GitHub |

Neste guia de instruções, você aprende a reconhecer e transcrever fala para 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 SpeechConfig instância. Essa classe inclui informações sobre sua assinatura, como sua chave e local/região associada, ponto de extremidade, host ou token de autorização.

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

Você pode inicializar SpeechConfig de algumas outras maneiras:

  • Use um ponto de extremidade e passe um ponto de extremidade do serviço de Fala. Uma chave ou token de autorização é opcional.
  • Use um host e passe um endereço de host. Uma chave ou token de autorização é opcional.
  • Use um token de autorização com a região/local associado.

Nota

Independentemente de estar executando reconhecimento de fala, síntese de fala, tradução ou reconhecimento de intenção, você sempre cria uma configuração.

Reconhecer voz a partir de um microfone

O reconhecimento de fala a partir de um microfone não é suportado no Node.js. É suportado apenas em um ambiente JavaScript baseado em navegador. Para obter mais informações, consulte o exemplo React e a implementação de fala em texto a partir de um microfone no GitHub. O exemplo 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ão de fala em texto.

Nota

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

Reconhecer a voz a partir de um ficheiro

Para reconhecer a fala de um arquivo de áudio, crie uma AudioConfig instância usando o fromWavFileInput() método que aceita um Buffer objeto. Em seguida, inicialize SpeechRecognizer passando 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 fala a partir de um fluxo na memória

Para muitos casos de uso, seus dados de áudio provavelmente vêm do Armazenamento de Blobs do Azure. Ou já está na memória como uma estrutura de ArrayBuffer dados brutos ou similar. O seguinte código:

  • Cria um fluxo push usando createPushStream()o .
  • Lê um arquivo .wav usando fs.createReadStream para fins de demonstração. Se você já tiver dados de áudio no ArrayBuffer, poderá pular diretamente para gravar o conteúdo no fluxo de entrada.
  • Cria uma configuração de áudio usando o fluxo 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();

O uso de um fluxo push como entrada pressupõe que os dados de áudio são dados brutos de modulação de código de pulso (PCM) que ignora quaisquer cabeçalhos. A API ainda funciona em certos casos se o cabeçalho não foi ignorado. Para obter os melhores resultados, considere a implementação de lógica para ler os cabeçalhos de modo que fs comece no início dos dados de áudio.

Processar erros

Os exemplos anteriores obtêm apenas o texto reconhecido da result.text propriedade. Para lidar com erros e outras respostas, você precisa escrever algum código para lidar com o resultado. O código a seguir avalia a result.reason propriedade e:

  • Imprime o resultado do reconhecimento: ResultReason.RecognizedSpeech.
  • Se não houver correspondência de reconhecimento, ele informa ao usuário: ResultReason.NoMatch.
  • Se for encontrado um erro, 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;
    }

Use o reconhecimento contínuo

Os exemplos anteriores usam o reconhecimento de tiro único, que reconhece um único enunciado. O fim de um único enunciado é determinado pela escuta do silêncio no final ou até que um máximo de 15 segundos de áudio seja processado.

Por outro lado, você pode usar o reconhecimento contínuo quando quiser controlar quando parar de reconhecer. Ele requer que você se inscreva no Recognizing, Recognizede Canceled eventos para obter os resultados de reconhecimento. Para interromper o reconhecimento, você deve ligar para stopContinuousRecognitionAsync. Aqui está 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, inscreva-se nos eventos enviados de SpeechRecognizer:

  • recognizing: Sinal para eventos que contêm resultados de reconhecimento intermediários.
  • recognized: Sinal para eventos que contêm resultados finais de reconhecimento, que indicam uma tentativa de reconhecimento bem-sucedida.
  • sessionStopped: Sinal para eventos que indicam o fim de uma sessão de reconhecimento (operação).
  • canceled: Sinal para eventos que contêm resultados de reconhecimento cancelados. Esses resultados indicam uma tentativa de reconhecimento que foi cancelada como resultado de uma solicitação de cancelamento direto. Como alternativa, indicam uma falha de transporte ou protocolo.
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 configurado, ligue startContinuousRecognitionAsync para começar a reconhecer:

speechRecognizer.startContinuousRecognitionAsync();

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

Alterar o idioma de partida

Uma tarefa comum para o reconhecimento de fala é especificar o idioma de entrada (ou fonte). O exemplo a seguir mostra como alterar o idioma de entrada para italiano. Em seu código, localize sua SpeechConfig instância e adicione esta linha diretamente abaixo dela:

speechConfig.speechRecognitionLanguage = "it-IT";

A speechRecognitionLanguage propriedade espera uma cadeia de caracteres de formato de localidade de idioma. Para obter mais informações, consulte a lista de localidades de fala para texto suportadas.

Identificação linguística

Você pode usar a identificação de idioma com fala para reconhecimento de texto quando precisar identificar o idioma em uma fonte de áudio e, em seguida, transcrevê-lo para 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 por meio 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 de Fala público. 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.

Pacote de documentação | de referência (Download) | Exemplos adicionais no GitHub

Neste guia de instruções, você aprende a reconhecer e transcrever fala para 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 para 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 por meio 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 de Fala público. 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.

Pacote de documentação | de referência (Download) | Exemplos adicionais no GitHub

Neste guia de instruções, você aprende a reconhecer e transcrever fala para 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 para 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 por meio 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 de Fala público. 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.

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

Neste guia de instruções, você aprende a reconhecer e transcrever fala para 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 SpeechConfig instância. Essa classe inclui informações sobre sua assinatura, como sua chave de fala e local/região associada, ponto de extremidade, host ou token de autorização.

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

Você pode inicializar SpeechConfig de algumas outras maneiras:

  • Use um ponto de extremidade e passe um ponto de extremidade do serviço de Fala. Uma chave de fala ou token de autorização é opcional.
  • Use um host e passe um endereço de host. Uma chave de fala ou token de autorização é opcional.
  • Use um token de autorização com a região/local associado.

Nota

Independentemente de estar executando reconhecimento de fala, síntese de fala, tradução ou reconhecimento de intenção, você sempre cria uma configuração.

Reconhecer voz a partir de um microfone

Para reconhecer a fala usando o microfone do dispositivo, crie uma SpeechRecognizer ocorrência sem passar AudioConfige, em seguida, passe 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()

Se você quiser usar um dispositivo de entrada de áudio específico , você precisa especificar o ID do dispositivo em AudioConfig, e passá-lo para o SpeechRecognizer parâmetro do audio_config construtor. Para obter mais informações sobre como obter a ID do dispositivo para o dispositivo de entrada de áudio, consulte Selecionar um dispositivo de entrada de áudio com o SDK de fala

Reconhecer a voz a partir de um ficheiro

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

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

Processar erros

Os exemplos anteriores obtêm apenas o texto reconhecido da result.text propriedade. Para lidar com erros e outras respostas, você precisa escrever algum código para lidar com o resultado. O código a seguir avalia a result.reason propriedade e:

  • Imprime o resultado do reconhecimento: speechsdk.ResultReason.RecognizedSpeech.
  • Se não houver correspondência de reconhecimento, ele informa ao usuário: speechsdk.ResultReason.NoMatch.
  • Se for encontrado um erro, 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?")

Use o reconhecimento contínuo

Os exemplos anteriores usam o reconhecimento de tiro único, que reconhece um único enunciado. O fim de um único enunciado é determinado pela escuta do silêncio no final ou até que um máximo de 15 segundos de áudio seja processado.

Por outro lado, você usa o reconhecimento contínuo quando deseja controlar quando parar de reconhecer. Ele requer que você se conecte para EventSignal obter os resultados de reconhecimento. Para interromper o reconhecimento, você deve chamar stop_continuous_recognition() ou stop_continuous_recognition(). Aqui está 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 presumir com segurança que ela não terminou:

done = False

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

  • Quando evt é recebida, a evt mensagem é impressa.
  • Depois evt de recebido, stop_continuous_recognition() é 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: Sinal para eventos que contêm resultados de reconhecimento intermediários.
  • recognized: Sinal para eventos que contêm resultados finais de reconhecimento, que indicam uma tentativa de reconhecimento bem-sucedida.
  • session_started: Sinal para eventos que indicam o início de uma sessão de reconhecimento (operação).
  • session_stopped: Sinal para eventos que indicam o fim de uma sessão de reconhecimento (operação).
  • canceled: Sinal para eventos que contêm resultados de reconhecimento cancelados. Esses resultados indicam uma tentativa de reconhecimento que foi cancelada como resultado de uma solicitação de cancelamento direto. Como alternativa, indicam uma falha de transporte ou protocolo.
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 configurado, você pode chamar start_continuous_recognition():

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

Alterar o idioma de partida

Uma tarefa comum para o reconhecimento de fala é especificar o idioma de entrada (ou fonte). O exemplo a seguir mostra como alterar o idioma de entrada para alemão. Em seu código, localize sua SpeechConfig instância 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 fala para texto suportadas.

Identificação linguística

Você pode usar a identificação de idioma com Fala para reconhecimento de texto quando precisar identificar o idioma em uma fonte de áudio e, em seguida, transcrevê-lo para 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 por meio 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 de Fala público. 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 fala para texto API REST de fala para texto para referência | de áudio curta Exemplos adicionais no GitHub

Neste guia de instruções, você aprende a reconhecer e transcrever fala para texto em tempo real.

Converter voz em texto

Em um prompt de comando, execute o seguinte comando. Insira os seguintes valores no comando:

  • A sua chave de subscrição para o serviço de Voz.
  • A sua região de serviço de Voz.
  • O caminho para arquivos de áudio de entrada. Você pode gerar arquivos de áudio usando texto para 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ê deve receber uma resposta com um corpo JSON como o exemplo a seguir:

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

Para obter mais informações, consulte a referência da API REST de fala em texto.

Neste guia de instruções, você aprende a reconhecer e transcrever fala para texto em tempo real.

Reconhecer voz a partir de um microfone

Ligue e ligue o microfone do PC. Desligue todas as aplicações que também possam utilizar o microfone. Alguns computadores têm um microfone embutido, 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, mude para o diretório que contém o arquivo binário da CLI de fala. Em seguida, execute o seguinte comando:

spx recognize --microphone

Nota

O padrão da CLI de fala é o inglês. Você pode escolher um idioma diferente da tabela de fala para texto. Por exemplo, adicionar --source de-DE para reconhecer a fala alemã.

Fale no microfone e você pode ver a transcrição de suas palavras em texto em tempo real. A CLI de fala para após um período de silêncio ou quando você seleciona Ctrl+C.

Reconhecer a voz a partir de um ficheiro

A CLI de fala pode reconhecer a fala em muitos formatos de arquivo e linguagens naturais. Neste exemplo, você pode usar qualquer arquivo .wav (16 KHz ou 8 KHz, 16 bits e PCM mono) que contenha fala em inglês. Ou, se você quiser uma amostra rápida, 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 para reconhecer a fala encontrada no arquivo de áudio:

spx recognize --file whatstheweatherlike.wav

Nota

O padrão da CLI de fala é o inglês. Você pode escolher um idioma diferente da tabela de fala para texto. Por exemplo, adicionar --source de-DE para reconhecer a fala alemã.

A CLI de Fala mostra 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 por meio 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 de Fala público. 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óximos passos