Guia de Início Rápido: Reconhecer intenções com o serviço de Fala e o LUIS

Importante

O LUIS será desativado em 1º de outubro de 2025. A partir de 1º de abril de 2023, não é possível criar novos recursos do LUIS. É recomendável migrar seus aplicativos LUIS para a compreensão da linguagem coloquial a fim de usufruir do suporte contínuo ao produto e dos recursos multilíngues.

A Compreensão da linguagem coloquial (CLU) está disponível para C# e C++ com o SDK de Fala versão 1.25 ou posterior. Consulte o início rápido para reconhecer intenções com o SDK de Fala e a CLU.

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

Neste início rápido, você usará o SDK de Fala e o serviço LUIS (Reconhecimento vocal) para reconhecer intenções em dados de áudio capturados de um microfone. Especificamente, você usará o SDK de Fala para capturar fala e um domínio predefinido do LUIS para identificar intenções de automação doméstica, assim como acender e apagar uma lâmpada.

Pré-requisitos

• Assinatura do Azure – Criar uma gratuitamente
• Criar um recurso de Linguagem no portal do Azure. Use o tipo de preço gratuito (F0) para experimentar o serviço e atualizar mais tarde para um nível pago para produção. Você não precisará de um recurso de Fala desta vez.
• Obtenha a chave e a região do recurso de Linguagem. Depois que o recurso de Linguagem for implantado, selecione Ir para o recurso para ver e gerenciar as chaves.

Criar um aplicativo LUIS para reconhecimento de intenção

Para concluir o início rápido do reconhecimento de intenção, você precisará criar uma conta do LUIS e um projeto usando a versão prévia do portal do LUIS. Este início rápido requer uma assinatura do LUIS em uma região em que o reconhecimento de intenção esteja disponível. Não é necessário ter uma assinatura do serviço de Fala.

A primeira coisa que você precisará fazer é criar uma conta e um aplicativo do LUIS usando a versão prévia do portal do LUIS. O aplicativo LUIS que você cria usará um domínio predefinido para a automação residencial, que fornece intenções, entidades e exemplos de enunciados. Quando terminar, você terá um ponto de extremidade do LUIS em execução na nuvem que você poderá chamar usando o SDK de Fala.

Siga estas instruções para criar seu aplicativo LUIS:

• Início Rápido: criar um aplicativo de domínio predefinido

Quando terminar, você precisará de quatro itens:

• Republicar com a Preparação da fala ativada
• Sua chave primária do LUIS
• Sua localização do LUIS
• Sua ID do aplicativo LUIS

Veja em que parte da versão prévia do portal do LUIS é possível encontrar essas informações:

1. Na versão prévia do portal do LUIS, selecione seu aplicativo e o botão Publicar.

2. Selecione o slot de Produção. Se estiver usando en-US, escolha Alterar configurações e alterne a opção Priming de fala para a posição Ativado. Em seguida, selecione o botão Publicar.

   Importante

   A Preparação da fala é altamente recomendável pois aprimorará a precisão do reconhecimento de fala.

   

3. Na versão prévia do portal do LUIS, selecione Gerenciar e, em seguida, selecione Recursos do Azure. Nessa página, você encontrará a chave e a localização (às vezes chamada de região) do recurso de previsão do LUIS.

   

4. Depois de obter a chave e o local, você precisará da ID do aplicativo. Selecione Configurações. a ID do aplicativo está disponível nessa página.

   

Abra o projeto no Visual Studio

Em seguida, abra seu projeto no Visual Studio.

1. Inicie o Visual Studio 2019.
2. Carregue o projeto e abra o Program.cs.

Comece com código de texto clichê

Vamos adicionar um código que funciona como um esqueleto para o projeto. Lembre-se de que você criou um método assíncrono chamado RecognizeIntentAsync().

using System;
using System.Threading.Tasks;
using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Intent;

namespace helloworld
{
    class Program
    {
        public static async Task RecognizeIntentAsync()
        {

        }

        static async Task Main()
        {
            await RecognizeIntentAsync();
            Console.WriteLine("Please press <Return> to continue.");
            Console.ReadLine();
        }
    }
}

Criar uma configuração de Fala

Antes de inicializar um objeto IntentRecognizer, é preciso criar uma configuração que use a chave e o local do recurso de previsão do LUIS.

Importante

A chave inicial e as chaves de criação não funcionarão. Você deve usar sua chave de previsão e o local que você criou anteriormente. Para obter mais informações, confira Criar um aplicativo LUIS para reconhecimento de intenção.

Insira esse código no método RecognizeIntentAsync(). Atualize estes valores:

• Substitua "YourLanguageUnderstandingSubscriptionKey" pela sua chave de previsão do LUIS.
• Substitua "YourLanguageUnderstandingServiceRegion" pelo seu local do LUIS. Use identificador de região da região.

Dica

Se precisar de ajuda para encontrar esses valores, confira Criar um aplicativo LUIS para reconhecimento de intenção.

Importante

Lembre-se de remover a chave do seu código quando terminar e nunca poste-a publicamente. Para produção, use uma maneira segura de armazenar e acessar suas credenciais, como o Azure Key Vault. Confira o artigo segurança dos serviços de IA do Azure para obter mais informações.

var config = SpeechConfig.FromSubscription(
    "YourLanguageUnderstandingSubscriptionKey",
    "YourLanguageUnderstandingServiceRegion");

Esta amostra usa o método FromSubscription() para criar o SpeechConfig. Para ver uma lista completa dos métodos disponíveis, confira a Classe SpeechConfig.

O SDK de Fala usará como padrão o reconhecimento do uso de en-us como idioma; confira Como reconhecer a fala para obter informações sobre como escolher o idioma de origem.

Inicializar um IntentRecognizer

Agora, vamos criar um IntentRecognizer. Esse objeto é criado dentro de uma instrução using para garantir a liberação adequada de recursos não gerenciados. Insira esse código no método RecognizeIntentAsync(), logo abaixo da configuração de Fala.

// Creates an intent recognizer using microphone as audio input.
using (var recognizer = new IntentRecognizer(config))
{

}

Adicione um LanguageUnderstandingModel e as intenções

Você precisa associar um LanguageUnderstandingModel ao reconhecedor de intenção e adicionar as intenções que deseja reconhecer. Vamos usar as intenções do domínio predefinido para a automação doméstica. Insira este código na instrução using da seção anterior. Substitua "YourLanguageUnderstandingAppId" pela ID do aplicativo LUIS.

Dica

Se precisar de ajuda para encontrar esse valor, confira Criar um aplicativo LUIS para reconhecimento de intenção.

// Creates a Language Understanding model using the app id, and adds specific intents from your model
var model = LanguageUnderstandingModel.FromAppId("YourLanguageUnderstandingAppId");
recognizer.AddIntent(model, "YourLanguageUnderstandingIntentName1", "id1");
recognizer.AddIntent(model, "YourLanguageUnderstandingIntentName2", "id2");
recognizer.AddIntent(model, "YourLanguageUnderstandingIntentName3", "any-IntentId-here");

Este exemplo usa a função AddIntent() para adicionar intenções individualmente. Se você quiser adicionar todas as intenções de um modelo, use AddAllIntents(model) e passe o modelo.

Reconhecer uma intenção

No objeto IntentRecognizer, chame o método RecognizeOnceAsync(). Esse método permite que o Serviço de Fala saiba que você está enviando uma única expressão para reconhecimento e permite parar o reconhecimento, assim que a frase é identificada.

Dentro da instrução using, adicione este código abaixo do seu modelo.

// Starts recognizing.
Console.WriteLine("Say something...");

// Starts intent recognition, and returns after a single utterance is recognized. The end of a
// single utterance is determined by listening for silence at the end or until a maximum of about 30
// seconds of audio is processed.  The task returns the recognition text as result. 
// Note: Since RecognizeOnceAsync() returns only a single utterance, it is suitable only for single
// shot recognition like command or query. 
// For long-running multi-utterance recognition, use StartContinuousRecognitionAsync() instead.
var result = await recognizer.RecognizeOnceAsync();

Exibir os resultados do reconhecimento (ou os erros)

Quando o Serviço de Fala retornar o resultado do reconhecimento, você poderá utilizá-lo. Para manter a simplicidade, vamos imprimir os resultados no console.

Dentro da instrução using, abaixo de RecognizeOnceAsync(), adicione este código:

// Checks result.
switch (result.Reason)
{
    case ResultReason.RecognizedIntent:
        Console.WriteLine($"RECOGNIZED: Text={result.Text}");
        Console.WriteLine($"    Intent Id: {result.IntentId}.");
        var json = result.Properties.GetProperty(PropertyId.LanguageUnderstandingServiceResponse_JsonResult);
        Console.WriteLine($"    Language Understanding JSON: {json}.");
        break;
    case ResultReason.RecognizedSpeech:
        Console.WriteLine($"RECOGNIZED: Text={result.Text}");
        Console.WriteLine($"    Intent not recognized.");
        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 update the subscription info?");
        }
        break;
}

Verificar o código

Neste momento, seu código deverá ter a seguinte aparência:

Observação

Adicionamos alguns comentários a esta versão.

//
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE.md file in the project root for full license information.
//

// <skeleton_1>
using System;
using System.Threading.Tasks;
using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Intent;

namespace helloworld
{
    class Program
    {
        public static async Task RecognizeIntentAsync()
        {
            // </skeleton_1>
            // Creates an instance of a speech config with specified subscription key
            // and service region. Note that in contrast to other services supported by
            // the Cognitive Services Speech SDK, the Language Understanding service
            // requires a specific subscription key from https://www.luis.ai/.
            // The Language Understanding service calls the required key 'endpoint key'.
            // Once you've obtained it, replace with below with your own Language Understanding subscription key
            // and service region (e.g., "westus").
            // The default language is "en-us".
            // <create_speech_configuration>
            var config = SpeechConfig.FromSubscription(
                "YourLanguageUnderstandingSubscriptionKey",
                "YourLanguageUnderstandingServiceRegion");
            // </create_speech_configuration>

            // <create_intent_recognizer_1>
            // Creates an intent recognizer using microphone as audio input.
            using (var recognizer = new IntentRecognizer(config))
            {
                // </create_intent_recognizer_1>

                // <add_intents>
                // Creates a Language Understanding model using the app id, and adds specific intents from your model
                var model = LanguageUnderstandingModel.FromAppId("YourLanguageUnderstandingAppId");
                recognizer.AddIntent(model, "YourLanguageUnderstandingIntentName1", "id1");
                recognizer.AddIntent(model, "YourLanguageUnderstandingIntentName2", "id2");
                recognizer.AddIntent(model, "YourLanguageUnderstandingIntentName3", "any-IntentId-here");
                // </add_intents>

                // To add all of the possible intents from a LUIS model to the recognizer, uncomment the line below:
                // recognizer.AddAllIntents(model);

                // <recognize_intent>
                // Starts recognizing.
                Console.WriteLine("Say something...");

                // Starts intent recognition, and returns after a single utterance is recognized. The end of a
                // single utterance is determined by listening for silence at the end or until a maximum of about 30
                // seconds of audio is processed.  The task returns the recognition text as result. 
                // Note: Since RecognizeOnceAsync() returns only a single utterance, it is suitable only for single
                // shot recognition like command or query. 
                // For long-running multi-utterance recognition, use StartContinuousRecognitionAsync() instead.
                var result = await recognizer.RecognizeOnceAsync();
                // </recognize_intent>

                // <print_results>
                // Checks result.
                switch (result.Reason)
                {
                    case ResultReason.RecognizedIntent:
                        Console.WriteLine($"RECOGNIZED: Text={result.Text}");
                        Console.WriteLine($"    Intent Id: {result.IntentId}.");
                        var json = result.Properties.GetProperty(PropertyId.LanguageUnderstandingServiceResponse_JsonResult);
                        Console.WriteLine($"    Language Understanding JSON: {json}.");
                        break;
                    case ResultReason.RecognizedSpeech:
                        Console.WriteLine($"RECOGNIZED: Text={result.Text}");
                        Console.WriteLine($"    Intent not recognized.");
                        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 update the subscription info?");
                        }
                        break;
                }
                // </print_results>
            // <create_intent_recognizer_2>
            }
            // </create_intent_recognizer_2>
        // <skeleton_2>
        }

        static async Task Main()
        {
            await RecognizeIntentAsync();
            Console.WriteLine("Please press <Return> to continue.");
            Console.ReadLine();
        }
    }
}
// </skeleton_2>

Compilar e executar o aplicativo

Agora está tudo pronto para você compilar o aplicativo e testar o reconhecimento de fala usando o serviço de fala.

1. Compilar o código: na barra de menus do Visual Studio, escolha Compilar>Compilar Solução.
2. Iniciar o aplicativo: na barra de menus, escolha Depurar>Iniciar Depuração ou pressione F5.
3. Iniciar o reconhecimento: ele solicitará que você fale uma frase em inglês. Sua fala é enviada ao Serviço de Fala, transcrita como texto e renderizada no console.

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

Neste início rápido, você usará o SDK de Fala e o serviço LUIS (Reconhecimento vocal) para reconhecer intenções em dados de áudio capturados de um microfone. Especificamente, você usará o SDK de Fala para capturar fala e um domínio predefinido do LUIS para identificar intenções de automação doméstica, assim como acender e apagar uma lâmpada.

Pré-requisitos

• Assinatura do Azure – Criar uma gratuitamente
• Criar um recurso de Linguagem no portal do Azure. Use o tipo de preço gratuito (F0) para experimentar o serviço e atualizar mais tarde para um nível pago para produção. Você não precisará de um recurso de Fala desta vez.
• Obtenha a chave e a região do recurso de Linguagem. Depois que o recurso de Linguagem for implantado, selecione Ir para o recurso para ver e gerenciar as chaves.

Criar um aplicativo LUIS para reconhecimento de intenção

Para concluir o início rápido do reconhecimento de intenção, você precisará criar uma conta do LUIS e um projeto usando a versão prévia do portal do LUIS. Este início rápido requer uma assinatura do LUIS em uma região em que o reconhecimento de intenção esteja disponível. Não é necessário ter uma assinatura do serviço de Fala.

A primeira coisa que você precisará fazer é criar uma conta e um aplicativo do LUIS usando a versão prévia do portal do LUIS. O aplicativo LUIS que você cria usará um domínio predefinido para a automação residencial, que fornece intenções, entidades e exemplos de enunciados. Quando terminar, você terá um ponto de extremidade do LUIS em execução na nuvem que você poderá chamar usando o SDK de Fala.

Siga estas instruções para criar seu aplicativo LUIS:

• Início Rápido: criar um aplicativo de domínio predefinido

Quando terminar, você precisará de quatro itens:

• Republicar com a Preparação da fala ativada
• Sua chave primária do LUIS
• Sua localização do LUIS
• Sua ID do aplicativo LUIS

Veja em que parte da versão prévia do portal do LUIS é possível encontrar essas informações:

1. Na versão prévia do portal do LUIS, selecione seu aplicativo e o botão Publicar.

2. Selecione o slot de Produção. Se estiver usando en-US, escolha Alterar configurações e alterne a opção Priming de fala para a posição Ativado. Em seguida, selecione o botão Publicar.

   Importante

   A Preparação da fala é altamente recomendável pois aprimorará a precisão do reconhecimento de fala.

   

3. Na versão prévia do portal do LUIS, selecione Gerenciar e, em seguida, selecione Recursos do Azure. Nessa página, você encontrará a chave e a localização (às vezes chamada de região) do recurso de previsão do LUIS.

   

4. Depois de obter a chave e o local, você precisará da ID do aplicativo. Selecione Configurações. a ID do aplicativo está disponível nessa página.

   

Abra o projeto no Visual Studio

Em seguida, abra seu projeto no Visual Studio.

1. Inicie o Visual Studio 2019.
2. Carregue o projeto e abra o helloworld.cpp.

Comece com código de texto clichê

Vamos adicionar um código que funciona como um esqueleto para o projeto. Lembre-se de que você criou um método assíncrono chamado recognizeIntent().

#include "stdafx.h"
#include <iostream>
#include <speechapi_cxx.h>

using namespace std;
using namespace Microsoft::CognitiveServices::Speech;
using namespace Microsoft::CognitiveServices::Speech::Intent;

void recognizeIntent()
{

}

int wmain()
{
    try
    {
        recognizeIntent();
    }
    catch (exception e)
    {
        cout << e.what();
    }
    cout << "Please press a key to continue.\n";
    cin.get();
    return 0;
}

Criar uma configuração de Fala

Antes de inicializar um objeto IntentRecognizer, é preciso criar uma configuração que use a chave e o local do recurso de previsão do LUIS.

Importante

A chave inicial e as chaves de criação não funcionarão. Você deve usar sua chave de previsão e o local que você criou anteriormente. Para obter mais informações, confira Criar um aplicativo LUIS para reconhecimento de intenção.

Insira esse código no método recognizeIntent(). Atualize estes valores:

• Substitua "YourLanguageUnderstandingSubscriptionKey" pela sua chave de previsão do LUIS.
• Substitua "YourLanguageUnderstandingServiceRegion" pelo seu local do LUIS. Use identificador de região da região.

Dica

Se precisar de ajuda para encontrar esses valores, confira Criar um aplicativo LUIS para reconhecimento de intenção.

Importante

Lembre-se de remover a chave do seu código quando terminar e nunca poste-a publicamente. Para produção, use uma maneira segura de armazenar e acessar suas credenciais, como o Azure Key Vault. Confira o artigo segurança dos serviços de IA do Azure para obter mais informações.

auto config = SpeechConfig::FromSubscription(
    "YourLanguageUnderstandingSubscriptionKey",
    "YourLanguageUnderstandingServiceRegion");

Esta amostra usa o método FromSubscription() para criar o SpeechConfig. Para ver uma lista completa dos métodos disponíveis, confira a Classe SpeechConfig.

O SDK de Fala usará como padrão o reconhecimento do uso de en-us como idioma; confira Como reconhecer a fala para obter informações sobre como escolher o idioma de origem.

Inicializar um IntentRecognizer

Agora, vamos criar um IntentRecognizer. Insira esse código no método recognizeIntent(), logo abaixo da configuração de Fala.

// Creates an intent recognizer using microphone as audio input.
auto recognizer = IntentRecognizer::FromConfig(config);

Adicione um LanguageUnderstandingModel e as Intenções

Você precisa associar um LanguageUnderstandingModel ao reconhecedor de intenção e adicionar as intenções que deseja reconhecer. Vamos usar as intenções do domínio predefinido para a automação doméstica.

Insira este código abaixo de seu IntentRecognizer. Substitua "YourLanguageUnderstandingAppId" pela ID do aplicativo LUIS.

Dica

Se precisar de ajuda para encontrar esse valor, confira Criar um aplicativo LUIS para reconhecimento de intenção.

// Creates a Language Understanding model using the app id, and adds specific intents from your model
auto model = LanguageUnderstandingModel::FromAppId("YourLanguageUnderstandingAppId");
recognizer->AddIntent(model, "YourLanguageUnderstandingIntentName1", "id1");
recognizer->AddIntent(model, "YourLanguageUnderstandingIntentName2", "id2");
recognizer->AddIntent(model, "YourLanguageUnderstandingIntentName3", "any-IntentId-here");

Este exemplo usa a função AddIntent() para adicionar intenções individualmente. Se você quiser adicionar todas as intenções de um modelo, use AddAllIntents(model) e passe o modelo.

Reconhecer uma intenção

No objeto IntentRecognizer, chame o método RecognizeOnceAsync(). Esse método permite que o Serviço de Fala saiba que você está enviando uma única expressão para reconhecimento e permite parar o reconhecimento, assim que a frase é identificada. Para simplificar, aguardaremos os resultados futuros retornarem para concluir.

Insira este código abaixo de seu modelo:

cout << "Say something...\n";

// Starts intent recognition, and returns after a single utterance is recognized. The end of a
// single utterance is determined by listening for silence at the end or until a maximum of about 30
// seconds of audio is processed.  The task returns the recognition text as result. 
// Note: Since RecognizeOnceAsync() returns only a single utterance, it is suitable only for single
// shot recognition like command or query. 
// For long-running multi-utterance recognition, use StartContinuousRecognitionAsync() instead.
auto result = recognizer->RecognizeOnceAsync().get();

Exibir os resultados do reconhecimento (ou os erros)

Quando o Serviço de Fala retornar o resultado do reconhecimento, você poderá utilizá-lo. Para manter a simplicidade, vamos imprimir o resultado no console.

Insira este código abaixo de auto result = recognizer->RecognizeOnceAsync().get();:

// Checks result.
if (result->Reason == ResultReason::RecognizedIntent)
{
    cout << "RECOGNIZED: Text=" << result->Text << std::endl;
    cout << "  Intent Id: " << result->IntentId << std::endl;
    cout << "  Intent Service JSON: " << result->Properties.GetProperty(PropertyId::LanguageUnderstandingServiceResponse_JsonResult) << std::endl;
}
else if (result->Reason == ResultReason::RecognizedSpeech)
{
    cout << "RECOGNIZED: Text=" << result->Text << " (intent could not be recognized)" << std::endl;
}
else if (result->Reason == ResultReason::NoMatch)
{
    cout << "NOMATCH: Speech could not be recognized." << std::endl;
}
else if (result->Reason == 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 update the subscription info?" << std::endl;
    }
}

Verificar o código

Neste momento, seu código deverá ter a seguinte aparência:

Observação

Adicionamos alguns comentários a esta versão.

//
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE.md file in the project root for full license information.
//

// <skeleton_1>
#include "stdafx.h"
#include <iostream>
#include <speechapi_cxx.h>

using namespace std;
using namespace Microsoft::CognitiveServices::Speech;
using namespace Microsoft::CognitiveServices::Speech::Intent;

void recognizeIntent()
{
    // </skeleton_1>
    // Creates an instance of a speech config with specified subscription key
    // and service region. Note that in contrast to other services supported by
    // the Cognitive Services Speech SDK, the Language Understanding service
    // requires a specific subscription key from https://www.luis.ai/.
    // The Language Understanding service calls the required key 'endpoint key'.
    // Once you've obtained it, replace with below with your own Language Understanding subscription key
    // and service region (e.g., "westus").
    // The default recognition language is "en-us".
    // <create_speech_configuration>
    auto config = SpeechConfig::FromSubscription(
        "YourLanguageUnderstandingSubscriptionKey",
        "YourLanguageUnderstandingServiceRegion");
    // </create_speech_configuration>

    // <create_intent_recognizer>
    // Creates an intent recognizer using microphone as audio input.
    auto recognizer = IntentRecognizer::FromConfig(config);
    // </create_intent_recognizer>

    // <add_intents>
    // Creates a Language Understanding model using the app id, and adds specific intents from your model
    auto model = LanguageUnderstandingModel::FromAppId("YourLanguageUnderstandingAppId");
    recognizer->AddIntent(model, "YourLanguageUnderstandingIntentName1", "id1");
    recognizer->AddIntent(model, "YourLanguageUnderstandingIntentName2", "id2");
    recognizer->AddIntent(model, "YourLanguageUnderstandingIntentName3", "any-IntentId-here");
    // </add_intents>

    // To add all of the possible intents from a LUIS model to the recognizer, uncomment the line below:
    // recognizer->AddAllIntents(model);

    // <recognize_intent>
    cout << "Say something...\n";

    // Starts intent recognition, and returns after a single utterance is recognized. The end of a
    // single utterance is determined by listening for silence at the end or until a maximum of about 30
    // seconds of audio is processed.  The task returns the recognition text as result. 
    // Note: Since RecognizeOnceAsync() returns only a single utterance, it is suitable only for single
    // shot recognition like command or query. 
    // For long-running multi-utterance recognition, use StartContinuousRecognitionAsync() instead.
    auto result = recognizer->RecognizeOnceAsync().get();
    // </recognize_intent>

    // <print_results>
    // Checks result.
    if (result->Reason == ResultReason::RecognizedIntent)
    {
        cout << "RECOGNIZED: Text=" << result->Text << std::endl;
        cout << "  Intent Id: " << result->IntentId << std::endl;
        cout << "  Intent Service JSON: " << result->Properties.GetProperty(PropertyId::LanguageUnderstandingServiceResponse_JsonResult) << std::endl;
    }
    else if (result->Reason == ResultReason::RecognizedSpeech)
    {
        cout << "RECOGNIZED: Text=" << result->Text << " (intent could not be recognized)" << std::endl;
    }
    else if (result->Reason == ResultReason::NoMatch)
    {
        cout << "NOMATCH: Speech could not be recognized." << std::endl;
    }
    else if (result->Reason == 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 update the subscription info?" << std::endl;
        }
    }
    // </print_results>
    // <skeleton_2>
}

int wmain()
{
    try
    {
        recognizeIntent();
    }
    catch (exception e)
    {
        cout << e.what();
    }
    cout << "Please press a key to continue.\n";
    cin.get();
    return 0;
}
// </skeleton_2>

Compilar e executar o aplicativo

Agora está tudo pronto para você compilar o aplicativo e testar o reconhecimento de fala usando o serviço de fala.

1. Compilar o código: na barra de menus do Visual Studio, escolha Compilar>Compilar Solução.
2. Iniciar o aplicativo: na barra de menus, escolha Depurar>Iniciar Depuração ou pressione F5.
3. Iniciar o reconhecimento: ele solicitará que você fale uma frase em inglês. Sua fala é enviada ao Serviço de Fala, transcrita como texto e renderizada no console.

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

Neste início rápido, você usará o SDK de Fala e o serviço LUIS (Reconhecimento vocal) para reconhecer intenções em dados de áudio capturados de um microfone. Especificamente, você usará o SDK de Fala para capturar fala e um domínio predefinido do LUIS para identificar intenções de automação doméstica, assim como acender e apagar uma lâmpada.

Pré-requisitos

• Assinatura do Azure – Criar uma gratuitamente
• Criar um recurso de Linguagem no portal do Azure. Use o tipo de preço gratuito (F0) para experimentar o serviço e atualizar mais tarde para um nível pago para produção. Você não precisará de um recurso de Fala desta vez.
• Obtenha a chave e a região do recurso de Linguagem. Depois que o recurso de Linguagem for implantado, selecione Ir para o recurso para ver e gerenciar as chaves.

Você também precisará instalar o SDK de Fala no ambiente de desenvolvimento e criar um projeto de exemplo vazio.

Criar um aplicativo LUIS para reconhecimento de intenção

Para concluir o início rápido do reconhecimento de intenção, você precisará criar uma conta do LUIS e um projeto usando a versão prévia do portal do LUIS. Este início rápido requer uma assinatura do LUIS em uma região em que o reconhecimento de intenção esteja disponível. Não é necessário ter uma assinatura do serviço de Fala.

A primeira coisa que você precisará fazer é criar uma conta e um aplicativo do LUIS usando a versão prévia do portal do LUIS. O aplicativo LUIS que você cria usará um domínio predefinido para a automação residencial, que fornece intenções, entidades e exemplos de enunciados. Quando terminar, você terá um ponto de extremidade do LUIS em execução na nuvem que você poderá chamar usando o SDK de Fala.

Siga estas instruções para criar seu aplicativo LUIS:

• Início Rápido: criar um aplicativo de domínio predefinido

Quando terminar, você precisará de quatro itens:

• Republicar com a Preparação da fala ativada
• Sua chave primária do LUIS
• Sua localização do LUIS
• Sua ID do aplicativo LUIS

Veja em que parte da versão prévia do portal do LUIS é possível encontrar essas informações:

1. Na versão prévia do portal do LUIS, selecione seu aplicativo e o botão Publicar.

2. Selecione o slot de Produção. Se estiver usando en-US, escolha Alterar configurações e alterne a opção Priming de fala para a posição Ativado. Em seguida, selecione o botão Publicar.

   Importante

   A Preparação da fala é altamente recomendável pois aprimorará a precisão do reconhecimento de fala.

   

3. Na versão prévia do portal do LUIS, selecione Gerenciar e, em seguida, selecione Recursos do Azure. Nessa página, você encontrará a chave e a localização (às vezes chamada de região) do recurso de previsão do LUIS.

   

4. Depois de obter a chave e o local, você precisará da ID do aplicativo. Selecione Configurações. a ID do aplicativo está disponível nessa página.

   

Abrir o projeto

1. Abra seu IDE preferencial.
2. Carregue o projeto e abra o Main.java.

Comece com código de texto clichê

Vamos adicionar um código que funciona como um esqueleto para o projeto.

package speechsdk.quickstart;

import com.microsoft.cognitiveservices.speech.*;
import com.microsoft.cognitiveservices.speech.intent.*;

/**
 * Quickstart: recognize speech using the Speech SDK for Java.
 */
public class Main {

    /**
     * @param args Arguments are ignored in this sample.
     */
    public static void main(String[] args) {

        } catch (Exception ex) {
            System.out.println("Unexpected exception: " + ex.getMessage());

            assert(false);
            System.exit(1);
        }
    }
}

Criar uma configuração de Fala

Antes de inicializar um objeto IntentRecognizer, é preciso criar uma configuração que use a chave e o local do recurso de previsão do LUIS.

Inserir este código no bloco try/catch no main(). Atualize estes valores:

• Substitua "YourLanguageUnderstandingSubscriptionKey" pela sua chave de previsão do LUIS.
• Substitua "YourLanguageUnderstandingServiceRegion" pelo seu local do LUIS. Use o Identificador de região da região correta

Dica

Se precisar de ajuda para encontrar esses valores, confira Criar um aplicativo LUIS para reconhecimento de intenção.

Importante

Lembre-se de remover a chave do seu código quando terminar e nunca poste-a publicamente. Para produção, use uma maneira segura de armazenar e acessar suas credenciais, como o Azure Key Vault. Confira o artigo segurança dos serviços de IA do Azure para obter mais informações.

// Replace below with with specified subscription key (called 'endpoint key' by the Language Understanding service)
String languageUnderstandingSubscriptionKey = "YourLanguageUnderstandingSubscriptionKey";
// Replace below with your own service region (e.g., "westus").
String languageUnderstandingServiceRegion = "YourLanguageUnderstandingServiceRegion";

// Creates an instance of intent recognizer with a given speech configuration.
// Recognizer is created with the default microphone audio input and default language "en-us".
try (SpeechConfig config = SpeechConfig.fromSubscription(languageUnderstandingSubscriptionKey, languageUnderstandingServiceRegion);

Esta amostra usa o método FromSubscription() para criar o SpeechConfig. Para ver uma lista completa dos métodos disponíveis, confira a Classe SpeechConfig.

O SDK de Fala usará como padrão o reconhecimento do uso de en-us como idioma; confira Como reconhecer a fala para obter informações sobre como escolher o idioma de origem.

Inicializar um IntentRecognizer

Agora, vamos criar um IntentRecognizer. Insira esse código logo abaixo da configuração de fala.

IntentRecognizer recognizer = new IntentRecognizer(config)) {

Adicione um LanguageUnderstandingModel e as Intenções

Você precisa associar um LanguageUnderstandingModel ao reconhecedor de intenção e adicionar as intenções que deseja reconhecer. Vamos usar as intenções do domínio predefinido para a automação doméstica.

Insira este código abaixo de seu IntentRecognizer. Substitua "YourLanguageUnderstandingAppId" pela ID do aplicativo LUIS.

Dica

Se precisar de ajuda para encontrar esse valor, confira Criar um aplicativo LUIS para reconhecimento de intenção.

// Creates a language understanding model using the app id, and adds specific intents from your model
LanguageUnderstandingModel model = LanguageUnderstandingModel.fromAppId("YourLanguageUnderstandingAppId");
recognizer.addIntent(model, "YourLanguageUnderstandingIntentName1", "id1");
recognizer.addIntent(model, "YourLanguageUnderstandingIntentName2", "id2");
recognizer.addIntent(model, "YourLanguageUnderstandingIntentName3", "any-IntentId-here");

Este exemplo usa a função addIntent() para adicionar intenções individualmente. Se você quiser adicionar todas as intenções de um modelo, use addAllIntents(model) e passe o modelo.

Reconhecer uma intenção

No objeto IntentRecognizer, chame o método recognizeOnceAsync(). Esse método permite que o Serviço de Fala saiba que você está enviando uma única expressão para reconhecimento e permite parar o reconhecimento, assim que a frase é identificada.

Insira este código abaixo de seu modelo:

System.out.println("Say something...");

// Starts recognition. It returns when the first utterance has been recognized.
IntentRecognitionResult result = recognizer.recognizeOnceAsync().get();

Exibir os resultados do reconhecimento (ou os erros)

Quando o Serviço de Fala retornar o resultado do reconhecimento, você poderá utilizá-lo. Para manter a simplicidade, vamos imprimir o resultado no console.

Insira este código abaixo de sua chamada para recognizeOnceAsync().

// Checks result.
if (result.getReason() == ResultReason.RecognizedIntent) {
    System.out.println("RECOGNIZED: Text=" + result.getText());
    System.out.println("    Intent Id: " + result.getIntentId());
    System.out.println("    Intent Service JSON: " + result.getProperties().getProperty(PropertyId.LanguageUnderstandingServiceResponse_JsonResult));
}
else if (result.getReason() == ResultReason.RecognizedSpeech) {
    System.out.println("RECOGNIZED: Text=" + result.getText());
    System.out.println("    Intent not recognized.");
}
else if (result.getReason() == ResultReason.NoMatch) {
    System.out.println("NOMATCH: Speech could not be recognized.");
}
else if (result.getReason() == 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 update the subscription info?");
    }
}

Verificar o código

Neste momento, seu código deverá ter a seguinte aparência:

Observação

Adicionamos alguns comentários a esta versão.

//
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE.md file in the project root for full license information.
//

// <skeleton_1>
package speechsdk.quickstart;

import com.microsoft.cognitiveservices.speech.*;
import com.microsoft.cognitiveservices.speech.intent.*;

/**
 * Quickstart: recognize speech using the Speech SDK for Java.
 */
public class Main {

    /**
     * @param args Arguments are ignored in this sample.
     */
    public static void main(String[] args) {
    // </skeleton_1>
        // <create_speech_configuration>
        // Replace below with with specified subscription key (called 'endpoint key' by the Language Understanding service)
        String languageUnderstandingSubscriptionKey = "YourLanguageUnderstandingSubscriptionKey";
        // Replace below with your own service region (e.g., "westus").
        String languageUnderstandingServiceRegion = "YourLanguageUnderstandingServiceRegion";

        // Creates an instance of intent recognizer with a given speech configuration.
        // Recognizer is created with the default microphone audio input and default language "en-us".
        try (SpeechConfig config = SpeechConfig.fromSubscription(languageUnderstandingSubscriptionKey, languageUnderstandingServiceRegion);
        // </create_speech_configuration>
            // <create_intent_recognizer>
            IntentRecognizer recognizer = new IntentRecognizer(config)) {
            // </create_intent_recognizer>

            // <add_intents>
            // Creates a language understanding model using the app id, and adds specific intents from your model
            LanguageUnderstandingModel model = LanguageUnderstandingModel.fromAppId("YourLanguageUnderstandingAppId");
            recognizer.addIntent(model, "YourLanguageUnderstandingIntentName1", "id1");
            recognizer.addIntent(model, "YourLanguageUnderstandingIntentName2", "id2");
            recognizer.addIntent(model, "YourLanguageUnderstandingIntentName3", "any-IntentId-here");
            // </add_intents>

            // To add all of the possible intents from a LUIS model to the recognizer, uncomment the line below:
            // recognizer.addAllIntents(model);

            // <recognize_intent>
            System.out.println("Say something...");

            // Starts recognition. It returns when the first utterance has been recognized.
            IntentRecognitionResult result = recognizer.recognizeOnceAsync().get();
            // </recognize_intent>

            // <print_result>
            // Checks result.
            if (result.getReason() == ResultReason.RecognizedIntent) {
                System.out.println("RECOGNIZED: Text=" + result.getText());
                System.out.println("    Intent Id: " + result.getIntentId());
                System.out.println("    Intent Service JSON: " + result.getProperties().getProperty(PropertyId.LanguageUnderstandingServiceResponse_JsonResult));
            }
            else if (result.getReason() == ResultReason.RecognizedSpeech) {
                System.out.println("RECOGNIZED: Text=" + result.getText());
                System.out.println("    Intent not recognized.");
            }
            else if (result.getReason() == ResultReason.NoMatch) {
                System.out.println("NOMATCH: Speech could not be recognized.");
            }
            else if (result.getReason() == 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 update the subscription info?");
                }
            }
            // </print_result>
        // <skeleton_2>
        } catch (Exception ex) {
            System.out.println("Unexpected exception: " + ex.getMessage());

            assert(false);
            System.exit(1);
        }
    }
}
// </skeleton_2>

Compilar e executar o aplicativo

Pressione F11 ou selecione Executar>Depurar. Os próximos 15 segundos de entrada de fala do microfone serão reconhecidos e registrados na janela do console.

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

Neste início rápido, você usará o SDK de Fala e o serviço LUIS (Reconhecimento vocal) para reconhecer intenções em dados de áudio capturados de um microfone. Especificamente, você usará o SDK de Fala para capturar fala e um domínio predefinido do LUIS para identificar intenções de automação doméstica, assim como acender e apagar uma lâmpada.

Pré-requisitos

• Assinatura do Azure – Criar uma gratuitamente
• Criar um recurso de Linguagem no portal do Azure. Use o tipo de preço gratuito (F0) para experimentar o serviço e atualizar mais tarde para um nível pago para produção. Você não precisará de um recurso de Fala desta vez.
• Obtenha a chave e a região do recurso de Linguagem. Depois que o recurso de Linguagem for implantado, selecione Ir para o recurso para ver e gerenciar as chaves.

Você também precisará instalar o SDK de Fala no ambiente de desenvolvimento e criar um projeto de exemplo vazio.

Criar um aplicativo LUIS para reconhecimento de intenção

Para concluir o início rápido do reconhecimento de intenção, você precisará criar uma conta do LUIS e um projeto usando a versão prévia do portal do LUIS. Este início rápido requer uma assinatura do LUIS em uma região em que o reconhecimento de intenção esteja disponível. Não é necessário ter uma assinatura do serviço de Fala.

A primeira coisa que você precisará fazer é criar uma conta e um aplicativo do LUIS usando a versão prévia do portal do LUIS. O aplicativo LUIS que você cria usará um domínio predefinido para a automação residencial, que fornece intenções, entidades e exemplos de enunciados. Quando terminar, você terá um ponto de extremidade do LUIS em execução na nuvem que você poderá chamar usando o SDK de Fala.

Siga estas instruções para criar seu aplicativo LUIS:

• Início Rápido: criar um aplicativo de domínio predefinido

Quando terminar, você precisará de quatro itens:

• Republicar com a Preparação da fala ativada
• Sua chave primária do LUIS
• Sua localização do LUIS
• Sua ID do aplicativo LUIS

Veja em que parte da versão prévia do portal do LUIS é possível encontrar essas informações:

1. Na versão prévia do portal do LUIS, selecione seu aplicativo e o botão Publicar.

2. Selecione o slot de Produção. Se estiver usando en-US, escolha Alterar configurações e alterne a opção Priming de fala para a posição Ativado. Em seguida, selecione o botão Publicar.

   Importante

   A Preparação da fala é altamente recomendável pois aprimorará a precisão do reconhecimento de fala.

   

3. Na versão prévia do portal do LUIS, selecione Gerenciar e, em seguida, selecione Recursos do Azure. Nessa página, você encontrará a chave e a localização (às vezes chamada de região) do recurso de previsão do LUIS.

   

4. Depois de obter a chave e o local, você precisará da ID do aplicativo. Selecione Configurações. a ID do aplicativo está disponível nessa página.

   

Comece com código de texto clichê

Vamos adicionar um código que funciona como um esqueleto para o projeto.

    <!DOCTYPE html>
    <html>
    <head>
    <title>Microsoft Azure AI Speech SDK JavaScript Quickstart</title>
    <meta charset="utf-8" />
    </head>
    <body style="font-family:'Helvetica Neue',Helvetica,Arial,sans-serif; font-size:13px;">
    </body>
    </html>

Adicionar elementos de interface do usuário

Agora, vamos adicionar uma interface do usuário básica para caixas de entrada, fazer referência ao JavaScript do SDK de Fala e obter um token de autorização, se disponível.

Importante

Lembre-se de remover a chave do seu código quando terminar e nunca poste-a publicamente. Para produção, use uma maneira segura de armazenar e acessar suas credenciais, como o Azure Key Vault. Confira o artigo segurança dos serviços de IA do Azure para obter mais informações.

<body style="font-family:'Helvetica Neue',Helvetica,Arial,sans-serif; font-size:13px;">
  <div id="content" style="display:none">
    <table width="100%">
      <tr>
        <td></td>
        <td><h1 style="font-weight:500;">Microsoft Azure AI Speech SDK JavaScript Quickstart</h1></td>
      </tr>
      <tr>
        <td align="right"><a href="https://learn.microsoft.com/azure/ai-services/speech-service/overview" target="_blank">Subscription</a>:</td>
        <td><input id="subscriptionKey" type="text" size="40" value="subscription"></td>
      </tr>
      <tr>
        <td align="right">Region</td>
        <td><input id="serviceRegion" type="text" size="40" value="YourServiceRegion"></td>
      </tr>
      <tr>
        <td align="right">Application ID:</td>
        <td><input id="appId" type="text" size="60" value="YOUR_LANGUAGE_UNDERSTANDING_APP_ID"></td>
      </tr>
      <tr>
        <td></td>
        <td><button id="startIntentRecognizeAsyncButton">Start Intent Recognition</button></td>
      </tr>
      <tr>
        <td align="right" valign="top">Input Text</td>
        <td><textarea id="phraseDiv" style="display: inline-block;width:500px;height:200px"></textarea></td>
      </tr>
      <tr>
        <td align="right" valign="top">Result</td>
        <td><textarea id="statusDiv" style="display: inline-block;width:500px;height:100px"></textarea></td>
      </tr>
    </table>
  </div>

  <script src="microsoft.cognitiveservices.speech.sdk.bundle.js"></script>

  <script>
  // Note: Replace the URL with a valid endpoint to retrieve
  //       authorization tokens for your subscription.
  var authorizationEndpoint = "token.php";

  function RequestAuthorizationToken() {
    if (authorizationEndpoint) {
      var a = new XMLHttpRequest();
      a.open("GET", authorizationEndpoint);
      a.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
      a.send("");
      a.onload = function() {
				var token = JSON.parse(atob(this.responseText.split(".")[1]));
				serviceRegion.value = token.region;
				authorizationToken = this.responseText;
				subscriptionKey.disabled = true;
				subscriptionKey.value = "using authorization token (hit F5 to refresh)";
				console.log("Got an authorization token: " + token);
      }
    }
  }
  </script>

  <script>
    // status fields and start button in UI
    var phraseDiv;
    var statusDiv;
    var startIntentRecognizeAsyncButton;

    // subscription key, region, and appId for LUIS services.
    var subscriptionKey, serviceRegion, appId;
    var authorizationToken;
    var SpeechSDK;
    var recognizer;

    document.addEventListener("DOMContentLoaded", function () {
      startIntentRecognizeAsyncButton = document.getElementById("startIntentRecognizeAsyncButton");
      subscriptionKey = document.getElementById("subscriptionKey");
      serviceRegion = document.getElementById("serviceRegion");
      appId = document.getElementById("appId");
      phraseDiv = document.getElementById("phraseDiv");
      statusDiv = document.getElementById("statusDiv");

      startIntentRecognizeAsyncButton.addEventListener("click", function () {
        startIntentRecognizeAsyncButton.disabled = true;
        phraseDiv.innerHTML = "";
        statusDiv.innerHTML = "";
      });

      if (!!window.SpeechSDK) {
        SpeechSDK = window.SpeechSDK;
        startIntentRecognizeAsyncButton.disabled = false;

        document.getElementById('content').style.display = 'block';
        document.getElementById('warning').style.display = 'none';

        // in case we have a function for getting an authorization token, call it.
        if (typeof RequestAuthorizationToken === "function") {
          RequestAuthorizationToken();
        }
      }
    });
  </script>

Criar uma configuração de Fala

Antes de inicializar um objeto SpeechRecognizer, é preciso criar uma configuração que use a região e a chave de assinatura. Insira esse código no método startRecognizeOnceAsyncButton.addEventListener().

Observação

O SDK de Fala usará como padrão o reconhecimento do uso de en-us como idioma; confira Como reconhecer a fala para obter informações sobre como escolher o idioma de origem.

        // if we got an authorization token, use the token. Otherwise use the provided subscription key
        var speechConfig;
        if (authorizationToken) {
          speechConfig = SpeechSDK.SpeechConfig.fromAuthorizationToken(authorizationToken, serviceRegion.value);
        } else {
          if (subscriptionKey.value === "" || subscriptionKey.value === "subscription") {
            alert("Please enter your Microsoft Azure AI Speech subscription key!");
            return;
          }
          startIntentRecognizeAsyncButton.disabled = false;
          speechConfig = SpeechSDK.SpeechConfig.fromSubscription(subscriptionKey.value, serviceRegion.value);
        }

        speechConfig.speechRecognitionLanguage = "en-US";

Criar uma configuração de Áudio

Agora, é preciso criar um objeto AudioConfig que aponte para o dispositivo de entrada. Insira esse código no método startIntentRecognizeAsyncButton.addEventListener(), logo abaixo da configuração de Fala.

        var audioConfig = SpeechSDK.AudioConfig.fromDefaultMicrophoneInput();

Inicializar um IntentRecognizer

Agora, crie o objeto IntentRecognizer usando os objetos SpeechConfig e AudioConfig criados anteriormente. Insira esse código no método startIntentRecognizeAsyncButton.addEventListener().

        recognizer = new SpeechSDK.IntentRecognizer(speechConfig, audioConfig);

Adicione um LanguageUnderstandingModel e as Intenções

Você precisa associar um LanguageUnderstandingModel ao reconhecedor de intenção e adicionar as intenções que deseja reconhecer. Vamos usar as intenções do domínio predefinido para a automação doméstica.

Insira este código abaixo de seu IntentRecognizer. Substitua "YourLanguageUnderstandingAppId" pela ID do aplicativo LUIS.

        if (appId.value !== "" && appId.value !== "YOUR_LANGUAGE_UNDERSTANDING_APP_ID") {
          var lm = SpeechSDK.LanguageUnderstandingModel.fromAppId(appId.value);

          recognizer.addAllIntents(lm);
        }

Observação

O SDK de Fala é compatível somente com os pontos de extremidade do LUIS v2.0. Você deve modificar manualmente a URL do ponto de extremidade v3.0 encontrada no campo de consulta de exemplo a fim de usar um padrão de URL v2.0. Os pontos de extremidade do LUIS v2.0 sempre seguem um destes dois padrões:

• https://{AzureResourceName}.cognitiveservices.azure.com/luis/v2.0/apps/{app-id}?subscription-key={subkey}&verbose=true&q=
• https://{Region}.api.cognitive.microsoft.com/luis/v2.0/apps/{app-id}?subscription-key={subkey}&verbose=true&q=

Reconhecer uma intenção

No objeto IntentRecognizer, chame o método recognizeOnceAsync(). Esse método permite que o Serviço de Fala saiba que você está enviando uma única expressão para reconhecimento e permite parar o reconhecimento, assim que a frase é identificada.

Insira esse código abaixo da adição de modelo:

        recognizer.recognizeOnceAsync(
          function (result) {
            window.console.log(result);

            phraseDiv.innerHTML = result.text + "\r\n";

            statusDiv.innerHTML += "(continuation) Reason: " + SpeechSDK.ResultReason[result.reason];
            switch (result.reason) {
              case SpeechSDK.ResultReason.RecognizedSpeech:
                statusDiv.innerHTML += " Text: " + result.text;
                break;
              case SpeechSDK.ResultReason.RecognizedIntent:
                statusDiv.innerHTML += " Text: " + result.text + " IntentId: " + result.intentId;

                // The actual JSON returned from Language Understanding is a bit more complex to get to, but it is available for things like
                // the entity name and type if part of the intent.
                statusDiv.innerHTML += " Intent JSON: " + result.properties.getProperty(SpeechSDK.PropertyId.LanguageUnderstandingServiceResponse_JsonResult);
                phraseDiv.innerHTML += result.properties.getProperty(SpeechSDK.PropertyId.LanguageUnderstandingServiceResponse_JsonResult) + "\r\n";
                break;
              case SpeechSDK.ResultReason.NoMatch:
                var noMatchDetail = SpeechSDK.NoMatchDetails.fromResult(result);
                statusDiv.innerHTML += " NoMatchReason: " + SpeechSDK.NoMatchReason[noMatchDetail.reason];
                break;
              case SpeechSDK.ResultReason.Canceled:
                var cancelDetails = SpeechSDK.CancellationDetails.fromResult(result);
                statusDiv.innerHTML += " CancellationReason: " + SpeechSDK.CancellationReason[cancelDetails.reason];

              if (cancelDetails.reason === SpeechSDK.CancellationReason.Error) {
                statusDiv.innerHTML += ": " + cancelDetails.errorDetails;
              }
            break;
            }
            statusDiv.innerHTML += "\r\n";
            startIntentRecognizeAsyncButton.disabled = false;
          },
          function (err) {
            window.console.log(err);

            phraseDiv.innerHTML += "ERROR: " + err;
            startIntentRecognizeAsyncButton.disabled = false;
          });

Verificar o código

<!DOCTYPE html>
<html>
<head>
  <title>Microsoft Cognitive Services Speech SDK JavaScript Quickstart</title>
  <meta charset="utf-8" />
</head>
<body style="font-family:'Helvetica Neue',Helvetica,Arial,sans-serif; font-size:13px;">
  <div id="warning">
    <h1 style="font-weight:500;">Speech Recognition Speech SDK not found (microsoft.cognitiveservices.speech.sdk.bundle.js missing).</h1>
  </div>
  
  <div id="content" style="display:none">
    <table width="100%">
      <tr>
        <td></td>
        <td><h1 style="font-weight:500;">Microsoft Cognitive Services Speech SDK JavaScript Quickstart</h1></td>
      </tr>
      <tr>
        <td align="right"><a href="https://docs.microsoft.com/azure/cognitive-services/speech-service/quickstarts/intent-recognition?pivots=programming-language-csharp#create-a-luis-app-for-intent-recognition" target="_blank">LUIS Primary Key</a>:</td>
        <td><input id="subscriptionKey" type="text" size="40" value="subscription"></td>
      </tr>
      <tr>
        <td align="right">LUIS Location</td>
        <td><input id="serviceRegion" type="text" size="40" value="YourServiceRegion"></td>
      </tr>
      <tr>
        <td align="right">LUIS App ID:</td>
        <td><input id="appId" type="text" size="60" value="YOUR_LANGUAGE_UNDERSTANDING_APP_ID"></td>
      </tr>
      <tr>
        <td></td>
        <td><button id="startIntentRecognizeAsyncButton">Start Intent Recognition</button></td>
      </tr>
      <tr>
        <td align="right" valign="top">Input Text</td>
        <td><textarea id="phraseDiv" style="display: inline-block;width:500px;height:200px"></textarea></td>
      </tr>
      <tr>
        <td align="right" valign="top">Result</td>
        <td><textarea id="statusDiv" style="display: inline-block;width:500px;height:100px"></textarea></td>
      </tr>
    </table>
  </div>

  <!-- Speech SDK reference sdk. -->
  <script src="https://aka.ms/csspeech/jsbrowserpackageraw"></script>

  <!-- Speech SDK USAGE -->
  <script>
    // status fields and start button in UI
    var phraseDiv;
    var statusDiv;
    var startIntentRecognizeAsyncButton;

    // subscription key and region for speech services.
    var subscriptionKey, serviceRegion, appId;
    var SpeechSDK;
    var recognizer;

    document.addEventListener("DOMContentLoaded", function () {

      startIntentRecognizeAsyncButton = document.getElementById("startIntentRecognizeAsyncButton");
      subscriptionKey = document.getElementById("subscriptionKey");
      serviceRegion = document.getElementById("serviceRegion");
      appId = document.getElementById("appId");
      phraseDiv = document.getElementById("phraseDiv");
      statusDiv = document.getElementById("statusDiv");

      startIntentRecognizeAsyncButton.addEventListener("click", function () {
        startIntentRecognizeAsyncButton.disabled = true;
        phraseDiv.innerHTML = "";
        statusDiv.innerHTML = "";

        let audioConfig = SpeechSDK.AudioConfig.fromDefaultMicrophoneInput();
        if (subscriptionKey.value === "" || subscriptionKey.value === "subscription") {
          alert("Please enter your Microsoft Cognitive Services Speech subscription key!");
          startIntentRecognizeAsyncButton.disabled = false;
          return;
        }
        var speechConfig = SpeechSDK.SpeechConfig.fromSubscription(subscriptionKey.value, serviceRegion.value);

        speechConfig.speechRecognitionLanguage = "en-US";
        recognizer = new SpeechSDK.IntentRecognizer(speechConfig, audioConfig);

        // Set up a Language Understanding Model from Language Understanding Intelligent Service (LUIS).
        // See https://www.luis.ai/home for more information on LUIS.
        if (appId.value !== "" && appId.value !== "YOUR_LANGUAGE_UNDERSTANDING_APP_ID") {
          var lm = SpeechSDK.LanguageUnderstandingModel.fromAppId(appId.value);

          recognizer.addAllIntents(lm);
        }

        recognizer.recognizeOnceAsync(
          function (result) {
            window.console.log(result);
            phraseDiv.innerHTML = result.text + "\r\n";

            statusDiv.innerHTML += "(continuation) Reason: " + SpeechSDK.ResultReason[result.reason];
            switch (result.reason) {

              case SpeechSDK.ResultReason.RecognizedSpeech:
                statusDiv.innerHTML += " Text: " + result.text;
                break;

              case SpeechSDK.ResultReason.RecognizedIntent:
                statusDiv.innerHTML += " Text: " + result.text + " IntentId: " + result.intentId;

                // The actual JSON returned from Language Understanding is a bit more complex to get to, but it is available for things like
                // the entity name and type if part of the intent.
                statusDiv.innerHTML += " Intent JSON: " + result.properties.getProperty(SpeechSDK.PropertyId.LanguageUnderstandingServiceResponse_JsonResult);
                phraseDiv.innerHTML += result.properties.getProperty(SpeechSDK.PropertyId.LanguageUnderstandingServiceResponse_JsonResult) + "\r\n";
                break;

              case SpeechSDK.ResultReason.NoMatch:
                var noMatchDetail = SpeechSDK.NoMatchDetails.fromResult(result);
                statusDiv.innerHTML += " NoMatchReason: " + SpeechSDK.NoMatchReason[noMatchDetail.reason];
                break;
                
              case SpeechSDK.ResultReason.Canceled:
                var cancelDetails = SpeechSDK.CancellationDetails.fromResult(result);
                statusDiv.innerHTML += " CancellationReason: " + SpeechSDK.CancellationReason[cancelDetails.reason];

                if (cancelDetails.reason === SpeechSDK.CancellationReason.Error) {
                  statusDiv.innerHTML += ": " + cancelDetails.errorDetails;
                }
                break;
            }
            statusDiv.innerHTML += "\r\n";
            startIntentRecognizeAsyncButton.disabled = false;
          },
          function (err) {
            window.console.log(err);

            phraseDiv.innerHTML += "ERROR: " + err;
            startIntentRecognizeAsyncButton.disabled = false;
        });
      });

      if (!!window.SpeechSDK) {
        SpeechSDK = window.SpeechSDK;
        startIntentRecognizeAsyncButton.disabled = false;

        document.getElementById('content').style.display = 'block';
        document.getElementById('warning').style.display = 'none';
      }
    });

  </script>
</body>
</html>

Criar a origem do token (opcional)

Caso deseje hospedar a página da Web em um servidor Web, é possível fornecer opcionalmente uma origem do token para seu aplicativo de demonstração. Dessa forma, sua chave de assinatura nunca sairá do seu servidor, permitindo que seus usuários usem funcionalidades de fala sem inserir nenhum código de autorização por si próprios.

Crie um arquivo chamado token.php. Neste exemplo, pressupomos que o seu servidor Web dê suporte à linguagem de script PHP com o cURL habilitado. Insira o seguinte código:

<?php
header('Access-Control-Allow-Origin: ' . $_SERVER['SERVER_NAME']);

// Replace with your own subscription key and service region (e.g., "westus").
$subscriptionKey = 'YourSubscriptionKey';
$region = 'YourServiceRegion';

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://' . $region . '.api.cognitive.microsoft.com/sts/v1.0/issueToken');
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, '{}');
curl_setopt($ch, CURLOPT_HTTPHEADER, array('Content-Type: application/json', 'Ocp-Apim-Subscription-Key: ' . $subscriptionKey));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
echo curl_exec($ch);
?>

Observação

Os tokens de autorização só têm um tempo de vida limitado. Este exemplo simplificado não mostra como atualizar os tokens de autorização automaticamente. Como um usuário, é possível recarregar manualmente a página ou pressionar F5 para atualizar.

Criar e executar o exemplo localmente

Para iniciar o aplicativo, clique duas vezes no arquivo index.html ou abra index.html com seu navegador da Web favorito. Ele apresentará uma GUI simples, permitindo que você insira sua chave LUIS, região LUIS e a ID do Aplicativo LUIS. Depois que esses campos tiverem sido inseridos, você poderá clicar no botão apropriado para disparar um reconhecimento usando o microfone.

Observação

Esse método não funciona no navegador do Safari. No Safari, a página da web de exemplo precisa ser hospedada em um servidor web. O Safari não permite que os sites carregados de um arquivo local usem o microfone.

Criar e executar o exemplo por meio de um servidor Web

Para iniciar seu aplicativo, abra seu navegador da Web favorito e aponte-o para a URL pública na qual a pasta está hospedada, insira sua região do LUIS, bem como sua ID de Aplicativo do LUIS e dispare um reconhecimento usando o microfone. Se configurado, ele adquirirá um token da sua origem de token e começará a reconhecer os comandos falados.

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

Neste início rápido, você usará o SDK de Fala e o serviço LUIS (Reconhecimento vocal) para reconhecer intenções em dados de áudio capturados de um microfone. Especificamente, você usará o SDK de Fala para capturar fala e um domínio predefinido do LUIS para identificar intenções de automação doméstica, assim como acender e apagar uma lâmpada.

Pré-requisitos

• Assinatura do Azure – Criar uma gratuitamente
• Criar um recurso de Linguagem no portal do Azure. Use o tipo de preço gratuito (F0) para experimentar o serviço e atualizar mais tarde para um nível pago para produção. Você não precisará de um recurso de Fala desta vez.
• Obtenha a chave e a região do recurso de Linguagem. Depois que o recurso de Linguagem for implantado, selecione Ir para o recurso para ver e gerenciar as chaves.

Você também precisará instalar o SDK de Fala no ambiente de desenvolvimento e criar um projeto de exemplo vazio.

Criar um aplicativo LUIS para reconhecimento de intenção

Para concluir o início rápido do reconhecimento de intenção, você precisará criar uma conta do LUIS e um projeto usando a versão prévia do portal do LUIS. Este início rápido requer uma assinatura do LUIS em uma região em que o reconhecimento de intenção esteja disponível. Não é necessário ter uma assinatura do serviço de Fala.

A primeira coisa que você precisará fazer é criar uma conta e um aplicativo do LUIS usando a versão prévia do portal do LUIS. O aplicativo LUIS que você cria usará um domínio predefinido para a automação residencial, que fornece intenções, entidades e exemplos de enunciados. Quando terminar, você terá um ponto de extremidade do LUIS em execução na nuvem que você poderá chamar usando o SDK de Fala.

Siga estas instruções para criar seu aplicativo LUIS:

• Início Rápido: criar um aplicativo de domínio predefinido

Quando terminar, você precisará de quatro itens:

• Republicar com a Preparação da fala ativada
• Sua chave primária do LUIS
• Sua localização do LUIS
• Sua ID do aplicativo LUIS

Veja em que parte da versão prévia do portal do LUIS é possível encontrar essas informações:

1. Na versão prévia do portal do LUIS, selecione seu aplicativo e o botão Publicar.

2. Selecione o slot de Produção. Se estiver usando en-US, escolha Alterar configurações e alterne a opção Priming de fala para a posição Ativado. Em seguida, selecione o botão Publicar.

   Importante

   A Preparação da fala é altamente recomendável pois aprimorará a precisão do reconhecimento de fala.

   

3. Na versão prévia do portal do LUIS, selecione Gerenciar e, em seguida, selecione Recursos do Azure. Nessa página, você encontrará a chave e a localização (às vezes chamada de região) do recurso de previsão do LUIS.

   

4. Depois de obter a chave e o local, você precisará da ID do aplicativo. Selecione Configurações. a ID do aplicativo está disponível nessa página.

   

Abrir o projeto

1. Abra seu IDE preferencial.
2. Crie um projeto e um arquivo chamado quickstart.py, que você deve abrir em seguida.

Comece com código de texto clichê

Vamos adicionar um código que funciona como um esqueleto para o projeto.

import azure.cognitiveservices.speech as speechsdk

print("Say something...")

Criar uma configuração de Fala

Antes de inicializar um objeto IntentRecognizer, é preciso criar uma configuração que use a chave e o local do recurso de previsão do LUIS.

Insira este código em quickstart.py. Atualize estes valores:

• Substitua "YourLanguageUnderstandingSubscriptionKey" pela sua chave de previsão do LUIS.
• Substitua "YourLanguageUnderstandingServiceRegion" pelo seu local do LUIS. Use o Identificador de região da região correta

Dica

Se precisar de ajuda para encontrar esses valores, confira Criar um aplicativo LUIS para reconhecimento de intenção.

Importante

Lembre-se de remover a chave do seu código quando terminar e nunca poste-a publicamente. Para produção, use uma maneira segura de armazenar e acessar suas credenciais, como o Azure Key Vault. Consulte o artigo sobre segurança do serviços de IA do Azure para obter mais informações.

# Set up the config for the intent recognizer (remember that this uses the Language Understanding key, not the Speech Services key)!
intent_config = speechsdk.SpeechConfig(
    subscription="YourLanguageUnderstandingSubscriptionKey",
    region="YourLanguageUnderstandingServiceRegion")

A amostra constrói o objeto SpeechConfig usando a chave e a região LUIS. Para ver uma lista completa dos métodos disponíveis, confira a Classe SpeechConfig.

O SDK de Fala usará como padrão o reconhecimento do uso de en-us como idioma; confira Como reconhecer a fala para obter informações sobre como escolher o idioma de origem.

Inicializar um IntentRecognizer

Agora, vamos criar um IntentRecognizer. Insira esse código logo abaixo da configuração de fala.

# Set up the intent recognizer
intent_recognizer = speechsdk.intent.IntentRecognizer(speech_config=intent_config)

Adicione um LanguageUnderstandingModel e as Intenções

Você precisa associar um LanguageUnderstandingModel ao reconhecedor de intenção e adicionar as intenções que deseja reconhecer. Vamos usar as intenções do domínio predefinido para a automação doméstica.

Insira este código abaixo de seu IntentRecognizer. Substitua "YourLanguageUnderstandingAppId" pela ID do aplicativo LUIS.

Dica

Se precisar de ajuda para encontrar esse valor, confira Criar um aplicativo LUIS para reconhecimento de intenção.

# set up the intents that are to be recognized. These can be a mix of simple phrases and
# intents specified through a LanguageUnderstanding Model.
model = speechsdk.intent.LanguageUnderstandingModel(app_id="YourLanguageUnderstandingAppId")
intents = [
    (model, "HomeAutomation.TurnOn"),
    (model, "HomeAutomation.TurnOff"),
    ("This is a test.", "test"),
    ("Switch to channel 34.", "34"),
    ("what's the weather like", "weather"),
]
intent_recognizer.add_intents(intents)

Esse exemplo usa a função add_intents() para adicionar uma lista de intenções definidas explicitamente. Se você quiser adicionar todas as intenções de um modelo, use add_all_intents(model) e passe o modelo.

Reconhecer uma intenção

No objeto IntentRecognizer, chame o método recognize_once(). Esse método permite que o Serviço de Fala saiba que você está enviando uma única expressão para reconhecimento e permite parar o reconhecimento, assim que a frase é identificada.

Insira este código abaixo de seu modelo.

intent_result = intent_recognizer.recognize_once()

Exibir os resultados do reconhecimento (ou os erros)

Quando o Serviço de Fala retornar o resultado do reconhecimento, você poderá utilizá-lo. Para manter a simplicidade, vamos imprimir o resultado no console.

Abaixo da chamada para recognize_once(), adicione este código.

# Check the results
if intent_result.reason == speechsdk.ResultReason.RecognizedIntent:
    print("Recognized: \"{}\" with intent id `{}`".format(intent_result.text, intent_result.intent_id))
elif intent_result.reason == speechsdk.ResultReason.RecognizedSpeech:
    print("Recognized: {}".format(intent_result.text))
elif intent_result.reason == speechsdk.ResultReason.NoMatch:
    print("No speech could be recognized: {}".format(intent_result.no_match_details))
elif intent_result.reason == speechsdk.ResultReason.Canceled:
    print("Intent recognition canceled: {}".format(intent_result.cancellation_details.reason))
    if intent_result.cancellation_details.reason == speechsdk.CancellationReason.Error:
        print("Error details: {}".format(intent_result.cancellation_details.error_details))

Verificar o código

Neste momento, seu código deverá ter a seguinte aparência.

Observação

Adicionamos alguns comentários a esta versão.

# Copyright (c) Microsoft. All rights reserved.
# Licensed under the MIT license. See LICENSE.md file in the project root for full license information.

# <skeleton>
import azure.cognitiveservices.speech as speechsdk

print("Say something...")
# </skeleton>

"""performs one-shot intent recognition from input from the default microphone"""

# <create_speech_configuration>
# Set up the config for the intent recognizer (remember that this uses the Language Understanding key, not the Speech Services key)!
intent_config = speechsdk.SpeechConfig(
    subscription="YourLanguageUnderstandingSubscriptionKey",
    region="YourLanguageUnderstandingServiceRegion")
# </create_speech_configuration>

# <create_intent_recognizer>
# Set up the intent recognizer
intent_recognizer = speechsdk.intent.IntentRecognizer(speech_config=intent_config)
# </create_intent_recognizer>

# <add_intents>
# set up the intents that are to be recognized. These can be a mix of simple phrases and
# intents specified through a LanguageUnderstanding Model.
model = speechsdk.intent.LanguageUnderstandingModel(app_id="YourLanguageUnderstandingAppId")
intents = [
    (model, "HomeAutomation.TurnOn"),
    (model, "HomeAutomation.TurnOff"),
    ("This is a test.", "test"),
    ("Switch to channel 34.", "34"),
    ("what's the weather like", "weather"),
]
intent_recognizer.add_intents(intents)
# </add_intents>

# To add all of the possible intents from a LUIS model to the recognizer, uncomment the line below:
# intent_recognizer.add_all_intents(model)

# Starts intent recognition, and returns after a single utterance is recognized. The end of a
# single utterance is determined by listening for silence at the end or until a maximum of about 30
# seconds of audio is processed. It returns the recognition text as result.
# Note: Since recognize_once() returns only a single utterance, it is suitable only for single
# shot recognition like command or query.
# For long-running multi-utterance recognition, use start_continuous_recognition() instead.
# <recognize_intent>
intent_result = intent_recognizer.recognize_once()
# </recognize_intent>

# <print_results>
# Check the results
if intent_result.reason == speechsdk.ResultReason.RecognizedIntent:
    print("Recognized: \"{}\" with intent id `{}`".format(intent_result.text, intent_result.intent_id))
elif intent_result.reason == speechsdk.ResultReason.RecognizedSpeech:
    print("Recognized: {}".format(intent_result.text))
elif intent_result.reason == speechsdk.ResultReason.NoMatch:
    print("No speech could be recognized: {}".format(intent_result.no_match_details))
elif intent_result.reason == speechsdk.ResultReason.Canceled:
    print("Intent recognition canceled: {}".format(intent_result.cancellation_details.reason))
    if intent_result.cancellation_details.reason == speechsdk.CancellationReason.Error:
        print("Error details: {}".format(intent_result.cancellation_details.error_details))
# </print_results>

Compilar e executar o aplicativo

Execute a amostra no console ou no IDE:

python quickstart.py

Os próximos 15 segundos de entrada de fala do microfone serão reconhecidos e registrados na janela do console.

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

O SDK de Fala para Go não dá suporte ao reconhecimento de intenção. Selecione outra linguagem de programação ou a referência do Go e exemplos vinculados no início deste artigo.

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

O SDK de Fala para Objective-C dá suporte ao reconhecimento de intenção, mas ainda não incluímos um guia a respeito. Selecione outra linguagem de programação para começar e saber mais sobre os conceitos ou confira a referência e exemplos em Objective-C vinculados no início deste artigo.

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

O SDK de Fala para Swift dá suporte ao reconhecimento de intenção, mas ainda não incluímos um guia a respeito. Selecione outra linguagem de programação para começar e saber mais sobre os conceitos ou confira a referência e exemplos em Swift vinculados no início deste artigo.

Referência da API REST de Conversão de fala em texto | API REST de fala em texto para breve referência de áudio | Exemplos adicionais no GitHub

Você pode usar a API REST para o reconhecimento de intenção, mas ainda não incluímos um guia a respeito. Selecione outra linguagem de programação para começar e saber mais sobre os conceitos.

A CLI (interface de linha de comando) de Fala dá suporte ao reconhecimento de intenção, mas ainda não incluímos um guia a respeito. Selecione outra linguagem de programação para começar e saber mais sobre os conceitos ou confira a visão geral da CLI de Fala para saber mais sobre a CLI.

Próximas etapas

Confira mais exemplos do LUIS no GitHub