Guia de início rápido: reconhecer intenções com o serviço de fala e o LUIS

Importante

LUIS será aposentado em 1º de outubro de 2025. A partir de 1 de abril de 2023 não é possível criar novos recursos LUIS. Recomendamos migrar seus aplicativos LUIS para o entendimento de linguagem conversacional para se beneficiar do suporte contínuo ao produto e dos recursos multilíngues.

O Entendimento de Linguagem de Conversação (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.

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

Neste guia de início rápido, você usará o SDK de fala e o serviço de compreensão de idioma (LUIS) para reconhecer intenções de dados de áudio capturados de um microfone. Especificamente, você usará o SDK de fala para capturar fala e um domínio pré-criado do LUIS para identificar intenções de automação residencial, como ligar e desligar uma luz.

Pré-requisitos

• Subscrição do Azure - Criar uma gratuitamente
• Crie um recurso de idioma no portal do Azure. Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para um nível pago para produção. Desta vez, você não precisará de um recurso de fala.
• Obtenha a chave de recurso de idioma e a região. Depois que o recurso de idioma for implantado, selecione Ir para o recurso para exibir e gerenciar chaves.

Criar um aplicativo LUIS para reconhecimento de intenção

Para concluir o início rápido de reconhecimento de intenção, você precisará criar uma conta LUIS e um projeto usando o portal de visualização do LUIS. Este início rápido requer uma assinatura LUIS em uma região onde o reconhecimento de intenção está disponível. Não é necessária uma subscrição do serviço de Voz.

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

Siga estas instruções para criar a sua aplicação LUIS:

• Guia de início rápido: criar aplicativo de domínio pré-criado

Quando terminar, precisará de quatro coisas:

• Republique com o Speech priming ativado
• A sua chave primária LUIS
• A sua localização LUIS
• O seu ID da aplicação LUIS

Aqui é onde você pode encontrar essas informações no portal de visualização do LUIS:

1. No portal de pré-visualização do LUIS, selecione a sua aplicação e, em seguida, selecione o botão Publicar .

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

   Importante

   O priming de fala é altamente recomendado, pois melhorará a precisão do reconhecimento de fala.

   

3. No portal de pré-visualização do LUIS, selecione Gerir e, em seguida, selecione Recursos do Azure. Nesta página, você encontrará sua chave LUIS e localização (às vezes referida como região) para seu recurso de previsão LUIS.

   

4. Depois de ter a sua chave e localização, precisará do ID da aplicação. Selecione Definições. o ID do seu aplicativo está disponível nesta página.

   

Abra seu projeto no Visual Studio

Em seguida, abra seu projeto no Visual Studio.

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

Comece com algum código clichê

Vamos adicionar algum código que funciona como um esqueleto para o nosso projeto. Observe 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 IntentRecognizer objeto, você precisa criar uma configuração que use a chave e o local para seu recurso de previsão LUIS.

Importante

Sua chave inicial e chaves de criação não funcionarão. Você deve usar a chave de previsão e o local criados anteriormente. Para obter mais informações, consulte Criar um aplicativo LUIS para reconhecimento de intenção.

Insira este código no RecognizeIntentAsync() método. Certifique-se de atualizar estes valores:

• Substitua "YourLanguageUnderstandingSubscriptionKey" pela sua chave de previsão LUIS.
• Substitua "YourLanguageUnderstandingServiceRegion" pela sua localização LUIS. Use o identificador de região da região.

Gorjeta

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

Importante

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

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

Este exemplo usa o FromSubscription() método para criar o SpeechConfig. Para obter uma lista completa dos métodos disponíveis, consulte SpeechConfig Class.

O SDK de Fala assumirá como padrão o reconhecimento usando en-us para o idioma, consulte Como reconhecer fala para obter informações sobre como escolher o idioma de origem.

Inicializar um IntentRecognizer

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

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

}

Adicionar um LanguageUnderstandingModel e intenções

Você precisa associar um LanguageUnderstandingModel ao reconhecedor de intenção e adicionar as intenções que deseja reconhecer. Vamos usar intenções do domínio pré-construído para automação residencial. Insira este código na instrução using da seção anterior. Certifique-se de que substitui "YourLanguageUnderstandingAppId" pelo ID da aplicação LUIS.

Gorjeta

Se precisar de ajuda para encontrar esse valor, consulte 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 AddIntent() função 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

A partir do IntentRecognizer objeto, você vai chamar o RecognizeOnceAsync() método. Esse método permite que o serviço de Fala saiba que você está enviando uma única frase para reconhecimento e que, uma vez identificada a frase, pare de reconhecer a fala.

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 resultados (ou erros) de reconhecimento

Quando o resultado do reconhecimento é retornado pelo serviço de fala, você vai querer fazer algo com ele. Vamos manter a simplicidade e imprimir os resultados para console.

Dentro da instrução using, abaixo 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;
}

Verifique o seu código

Neste ponto, seu código deve ter esta aparência:

Nota

Adicionámos 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>

Crie e execute seu aplicativo

Agora você está pronto para criar seu aplicativo e testar nosso reconhecimento de fala usando o serviço de fala.

1. Compilar o código - Na barra de menus do Visual Studio, escolha Build>Build Solution.
2. Iniciar seu aplicativo - Na barra de menus, escolha Depurar>Iniciar Depuração ou pressione F5.
3. Comece o reconhecimento - Ele solicitará que você fale uma frase em inglês. Sua fala é enviada para o serviço de fala, transcrita como texto e processada no console.

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

Neste guia de início rápido, você usará o SDK de fala e o serviço de compreensão de idioma (LUIS) para reconhecer intenções de dados de áudio capturados de um microfone. Especificamente, você usará o SDK de fala para capturar fala e um domínio pré-criado do LUIS para identificar intenções de automação residencial, como ligar e desligar uma luz.

Pré-requisitos

• Subscrição do Azure - Criar uma gratuitamente
• Crie um recurso de idioma no portal do Azure. Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para um nível pago para produção. Desta vez, você não precisará de um recurso de fala.
• Obtenha a chave de recurso de idioma e a região. Depois que o recurso de idioma for implantado, selecione Ir para o recurso para exibir e gerenciar chaves.

Criar um aplicativo LUIS para reconhecimento de intenção

Para concluir o início rápido de reconhecimento de intenção, você precisará criar uma conta LUIS e um projeto usando o portal de visualização do LUIS. Este início rápido requer uma assinatura LUIS em uma região onde o reconhecimento de intenção está disponível. Não é necessária uma subscrição do serviço de Voz.

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

Siga estas instruções para criar a sua aplicação LUIS:

• Guia de início rápido: criar aplicativo de domínio pré-criado

Quando terminar, precisará de quatro coisas:

• Republique com o Speech priming ativado
• A sua chave primária LUIS
• A sua localização LUIS
• O seu ID da aplicação LUIS

Aqui é onde você pode encontrar essas informações no portal de visualização do LUIS:

1. No portal de pré-visualização do LUIS, selecione a sua aplicação e, em seguida, selecione o botão Publicar .

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

   Importante

   O priming de fala é altamente recomendado, pois melhorará a precisão do reconhecimento de fala.

   

3. No portal de pré-visualização do LUIS, selecione Gerir e, em seguida, selecione Recursos do Azure. Nesta página, você encontrará sua chave LUIS e localização (às vezes referida como região) para seu recurso de previsão LUIS.

   

4. Depois de ter a sua chave e localização, precisará do ID da aplicação. Selecione Definições. o ID do seu aplicativo está disponível nesta página.

   

Abra seu projeto no Visual Studio

Em seguida, abra seu projeto no Visual Studio.

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

Comece com algum código clichê

Vamos adicionar algum código que funciona como um esqueleto para o nosso projeto. Observe 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 IntentRecognizer objeto, você precisa criar uma configuração que use a chave e o local para seu recurso de previsão LUIS.

Importante

Sua chave inicial e chaves de criação não funcionarão. Você deve usar a chave de previsão e o local criados anteriormente. Para obter mais informações, consulte Criar um aplicativo LUIS para reconhecimento de intenção.

Insira este código no recognizeIntent() método. Certifique-se de atualizar estes valores:

• Substitua "YourLanguageUnderstandingSubscriptionKey" pela sua chave de previsão LUIS.
• Substitua "YourLanguageUnderstandingServiceRegion" pela sua localização LUIS. Use o identificador de região da região.

Gorjeta

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

Importante

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

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

Este exemplo usa o FromSubscription() método para criar o SpeechConfig. Para obter uma lista completa dos métodos disponíveis, consulte SpeechConfig Class.

O SDK de Fala assumirá como padrão o reconhecimento usando en-us para o idioma, consulte Como reconhecer fala para obter informações sobre como escolher o idioma de origem.

Inicializar um IntentRecognizer

Agora, vamos criar um IntentRecognizerarquivo . Insira este código no método, logo abaixo da recognizeIntent() sua configuração de fala.

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

Adicionar um LanguageUnderstandingModel e intenções

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

Insira este código abaixo do seu IntentRecognizerarquivo . Certifique-se de que substitui "YourLanguageUnderstandingAppId" pelo ID da aplicação LUIS.

Gorjeta

Se precisar de ajuda para encontrar esse valor, consulte 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 AddIntent() função 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

A partir do IntentRecognizer objeto, você vai chamar o RecognizeOnceAsync() método. Esse método permite que o serviço de Fala saiba que você está enviando uma única frase para reconhecimento e que, uma vez identificada a frase, pare de reconhecer a fala. Para simplificar, vamos esperar o futuro voltar para completar.

Insira este código abaixo do 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 (ou erros) de reconhecimento

Quando o resultado do reconhecimento é retornado pelo serviço de fala, você vai querer fazer algo com ele. Vamos simplificá-lo e imprimir o resultado para console.

Insira este código abaixo 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;
    }
}

Verifique o seu código

Neste ponto, seu código deve ter esta aparência:

Nota

Adicionámos 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>

Crie e execute seu aplicativo

Agora você está pronto para criar seu aplicativo e testar nosso reconhecimento de fala usando o serviço de fala.

1. Compilar o código - Na barra de menus do Visual Studio, escolha Build>Build Solution.
2. Iniciar seu aplicativo - Na barra de menus, escolha Depurar>Iniciar Depuração ou pressione F5.
3. Comece o reconhecimento - Ele solicitará que você fale uma frase em inglês. Sua fala é enviada para o serviço de fala, transcrita como texto e processada no console.

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

Neste guia de início rápido, você usará o SDK de fala e o serviço de compreensão de idioma (LUIS) para reconhecer intenções de dados de áudio capturados de um microfone. Especificamente, você usará o SDK de fala para capturar fala e um domínio pré-criado do LUIS para identificar intenções de automação residencial, como ligar e desligar uma luz.

Pré-requisitos

• Subscrição do Azure - Criar uma gratuitamente
• Crie um recurso de idioma no portal do Azure. Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para um nível pago para produção. Desta vez, você não precisará de um recurso de fala.
• Obtenha a chave de recurso de idioma e a região. Depois que o recurso de idioma for implantado, selecione Ir para o recurso para exibir e gerenciar chaves.

Você também precisa instalar o SDK de fala para seu 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 de reconhecimento de intenção, você precisará criar uma conta LUIS e um projeto usando o portal de visualização do LUIS. Este início rápido requer uma assinatura LUIS em uma região onde o reconhecimento de intenção está disponível. Não é necessária uma subscrição do serviço de Voz.

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

Siga estas instruções para criar a sua aplicação LUIS:

• Guia de início rápido: criar aplicativo de domínio pré-criado

Quando terminar, precisará de quatro coisas:

• Republique com o Speech priming ativado
• A sua chave primária LUIS
• A sua localização LUIS
• O seu ID da aplicação LUIS

Aqui é onde você pode encontrar essas informações no portal de visualização do LUIS:

1. No portal de pré-visualização do LUIS, selecione a sua aplicação e, em seguida, selecione o botão Publicar .

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

   Importante

   O priming de fala é altamente recomendado, pois melhorará a precisão do reconhecimento de fala.

   

3. No portal de pré-visualização do LUIS, selecione Gerir e, em seguida, selecione Recursos do Azure. Nesta página, você encontrará sua chave LUIS e localização (às vezes referida como região) para seu recurso de previsão LUIS.

   

4. Depois de ter a sua chave e localização, precisará do ID da aplicação. Selecione Definições. o ID do seu aplicativo está disponível nesta página.

   

Abra o seu projeto

1. Abra seu IDE preferido.
2. Carregue seu projeto e abra Main.javao .

Comece com algum código clichê

Vamos adicionar algum código que funciona como um esqueleto para o nosso 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 IntentRecognizer objeto, você precisa criar uma configuração que use a chave e o local para seu recurso de previsão LUIS.

Insira este código no bloco try / catch em main(). Certifique-se de atualizar estes valores:

• Substitua "YourLanguageUnderstandingSubscriptionKey" pela sua chave de previsão LUIS.
• Substitua "YourLanguageUnderstandingServiceRegion" pela sua localização LUIS. Usar identificador de região da região

Gorjeta

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

Importante

Lembre-se de remover a chave do seu código quando terminar e nunca publicá-la publicamente. Para produção, use uma maneira segura de armazenar e acessar suas credenciais, como o Azure Key Vault. Consulte o artigo de 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);

Este exemplo usa o FromSubscription() método para criar o SpeechConfig. Para obter uma lista completa dos métodos disponíveis, consulte SpeechConfig Class.

O SDK de Fala assumirá como padrão o reconhecimento usando en-us para o idioma, consulte Como reconhecer fala para obter informações sobre como escolher o idioma de origem.

Inicializar um IntentRecognizer

Agora, vamos criar um IntentRecognizerarquivo . Insira este código logo abaixo da sua configuração de Fala.

IntentRecognizer recognizer = new IntentRecognizer(config)) {

Adicionar um LanguageUnderstandingModel e intenções

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

Insira este código abaixo do seu IntentRecognizerarquivo . Certifique-se de que substitui "YourLanguageUnderstandingAppId" pelo ID da aplicação LUIS.

Gorjeta

Se precisar de ajuda para encontrar esse valor, consulte 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 addIntent() função 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

A partir do IntentRecognizer objeto, você vai chamar o recognizeOnceAsync() método. Esse método permite que o serviço de Fala saiba que você está enviando uma única frase para reconhecimento e que, uma vez identificada a frase, pare de reconhecer a fala.

Insira este código abaixo do 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 (ou erros) de reconhecimento

Quando o resultado do reconhecimento é retornado pelo serviço de fala, você vai querer fazer algo com ele. Vamos simplificá-lo e imprimir o resultado para console.

Insira este código abaixo da 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?");
    }
}

Verifique o seu código

Neste ponto, seu código deve ter esta aparência:

Nota

Adicionámos 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>

Crie e execute seu aplicativo

Pressione F11 ou selecione Executar>depuração. Os próximos 15 segundos de entrada de voz do microfone serão reconhecidos e registados na janela da consola.

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

Neste guia de início rápido, você usará o SDK de fala e o serviço de compreensão de idioma (LUIS) para reconhecer intenções de dados de áudio capturados de um microfone. Especificamente, você usará o SDK de fala para capturar fala e um domínio pré-criado do LUIS para identificar intenções de automação residencial, como ligar e desligar uma luz.

Pré-requisitos

• Subscrição do Azure - Criar uma gratuitamente
• Crie um recurso de idioma no portal do Azure. Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para um nível pago para produção. Desta vez, você não precisará de um recurso de fala.
• Obtenha a chave de recurso de idioma e a região. Depois que o recurso de idioma for implantado, selecione Ir para o recurso para exibir e gerenciar chaves.

Você também precisa instalar o SDK de fala para seu 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 de reconhecimento de intenção, você precisará criar uma conta LUIS e um projeto usando o portal de visualização do LUIS. Este início rápido requer uma assinatura LUIS em uma região onde o reconhecimento de intenção está disponível. Não é necessária uma subscrição do serviço de Voz.

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

Siga estas instruções para criar a sua aplicação LUIS:

• Guia de início rápido: criar aplicativo de domínio pré-criado

Quando terminar, precisará de quatro coisas:

• Republique com o Speech priming ativado
• A sua chave primária LUIS
• A sua localização LUIS
• O seu ID da aplicação LUIS

Aqui é onde você pode encontrar essas informações no portal de visualização do LUIS:

1. No portal de pré-visualização do LUIS, selecione a sua aplicação e, em seguida, selecione o botão Publicar .

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

   Importante

   O priming de fala é altamente recomendado, pois melhorará a precisão do reconhecimento de fala.

   

3. No portal de pré-visualização do LUIS, selecione Gerir e, em seguida, selecione Recursos do Azure. Nesta página, você encontrará sua chave LUIS e localização (às vezes referida como região) para seu recurso de previsão LUIS.

   

4. Depois de ter a sua chave e localização, precisará do ID da aplicação. Selecione Definições. o ID do seu aplicativo está disponível nesta página.

   

Comece com algum código clichê

Vamos adicionar algum código que funciona como um esqueleto para o nosso 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 da interface do usuário

Agora, adicionaremos algumas interfaces do usuário básicas para caixas de entrada, faremos referência ao JavaScript do SDK de Fala e pegaremos um token de autorização, se disponível.

Importante

Lembre-se de remover a chave do seu código quando terminar e nunca publicá-la publicamente. Para produção, use uma maneira segura de armazenar e acessar suas credenciais, como o Azure Key Vault. Consulte o artigo de 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 SpeechRecognizer objeto, você precisa criar uma configuração que use sua chave de assinatura e região de assinatura. Insira este código no startRecognizeOnceAsyncButton.addEventListener() método.

Nota

O SDK de Fala assumirá como padrão o reconhecimento usando en-us para o idioma, consulte Como reconhecer 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, você precisa criar um AudioConfig objeto que aponte para o seu dispositivo de entrada. Insira este código no método, logo abaixo da startIntentRecognizeAsyncButton.addEventListener() sua configuração de fala.

        var audioConfig = SpeechSDK.AudioConfig.fromDefaultMicrophoneInput();

Inicializar um IntentRecognizer

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

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

Adicionar um LanguageUnderstandingModel e intenções

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

Insira este código abaixo do seu IntentRecognizerarquivo . Certifique-se de que substitui "YourLanguageUnderstandingAppId" pelo ID da aplicação LUIS.

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

          recognizer.addAllIntents(lm);
        }

Nota

O SDK de fala suporta apenas pontos de extremidade LUIS v2.0. Você deve modificar manualmente a URL do ponto de extremidade v3.0 encontrada no campo de consulta de exemplo para usar um padrão de URL v2.0. Os pontos de extremidade 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

A partir do IntentRecognizer objeto, você vai chamar o recognizeOnceAsync() método. Esse método permite que o serviço de Fala saiba que você está enviando uma única frase para reconhecimento e que, uma vez identificada a frase, pare de reconhecer a fala.

Insira este código abaixo da adição do 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;
          });

Verifique o seu 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)

No caso de querer alojar a página Web num servidor Web, pode fornecer opcionalmente uma origem de token para a aplicação de demonstração. Dessa forma, a chave de subscrição nunca vai sair do servidor, o que permite aos utilizadores usufruir das capacidades de voz sem introduzir qualquer código de autorização.

Crie um novo ficheiro com o nome token.php. Neste exemplo, assumimos que seu servidor web suporta a linguagem de script PHP com curl habilitado. Introduza 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);
?>

Nota

Os tokens de autorização têm uma duração limitada. Este exemplo simplificado não mostra como atualizar automaticamente os tokens de autorização. Como utilizador, pode recarregar manualmente a página ou premir F5 para atualizar.

Criar e executar o exemplo localmente

Para iniciar a aplicação, faça duplo clique no ficheiro index.html ou abra-o com o seu browser favorito. Ele apresentará uma GUI simples permitindo que você insira sua chave LUIS, região LUIS e ID do aplicativo LUIS. Depois que esses campos forem inseridos, você pode clicar no botão apropriado para acionar um reconhecimento usando o microfone.

Nota

Este método não funciona no navegador Safari. No Safari, a página Web de exemplo tem de estar alojada num servidor Web; O Safari não permite que sites carregados a partir de um ficheiro local utilizem o microfone.

Criar e executar o exemplo através de um servidor Web

Para iniciar seu aplicativo, abra seu navegador da Web favorito e aponte para a URL pública na qual você hospeda a pasta, insira sua região LUIS, bem como sua ID de aplicativo LUIS e acione um reconhecimento usando o microfone. Se configurado, ele adquirirá um token da sua fonte de token e começará a reconhecer comandos falados.

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

Neste guia de início rápido, você usará o SDK de fala e o serviço de compreensão de idioma (LUIS) para reconhecer intenções de dados de áudio capturados de um microfone. Especificamente, você usará o SDK de fala para capturar fala e um domínio pré-criado do LUIS para identificar intenções de automação residencial, como ligar e desligar uma luz.

Pré-requisitos

• Subscrição do Azure - Criar uma gratuitamente
• Crie um recurso de idioma no portal do Azure. Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para um nível pago para produção. Desta vez, você não precisará de um recurso de fala.
• Obtenha a chave de recurso de idioma e a região. Depois que o recurso de idioma for implantado, selecione Ir para o recurso para exibir e gerenciar chaves.

Você também precisa instalar o SDK de fala para seu 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 de reconhecimento de intenção, você precisará criar uma conta LUIS e um projeto usando o portal de visualização do LUIS. Este início rápido requer uma assinatura LUIS em uma região onde o reconhecimento de intenção está disponível. Não é necessária uma subscrição do serviço de Voz.

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

Siga estas instruções para criar a sua aplicação LUIS:

• Guia de início rápido: criar aplicativo de domínio pré-criado

Quando terminar, precisará de quatro coisas:

• Republique com o Speech priming ativado
• A sua chave primária LUIS
• A sua localização LUIS
• O seu ID da aplicação LUIS

Aqui é onde você pode encontrar essas informações no portal de visualização do LUIS:

1. No portal de pré-visualização do LUIS, selecione a sua aplicação e, em seguida, selecione o botão Publicar .

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

   Importante

   O priming de fala é altamente recomendado, pois melhorará a precisão do reconhecimento de fala.

   

3. No portal de pré-visualização do LUIS, selecione Gerir e, em seguida, selecione Recursos do Azure. Nesta página, você encontrará sua chave LUIS e localização (às vezes referida como região) para seu recurso de previsão LUIS.

   

4. Depois de ter a sua chave e localização, precisará do ID da aplicação. Selecione Definições. o ID do seu aplicativo está disponível nesta página.

   

Abra o seu projeto

1. Abra seu IDE preferido.
2. Crie um novo projeto e crie um arquivo chamado quickstart.pye, em seguida, abra-o.

Comece com algum código clichê

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

import azure.cognitiveservices.speech as speechsdk

print("Say something...")

Criar uma configuração de Fala

Antes de inicializar um IntentRecognizer objeto, você precisa criar uma configuração que use a chave e o local para seu recurso de previsão LUIS.

Insira este código em quickstart.py. Certifique-se de atualizar estes valores:

• Substitua "YourLanguageUnderstandingSubscriptionKey" pela sua chave de previsão LUIS.
• Substitua "YourLanguageUnderstandingServiceRegion" pela sua localização LUIS. Usar identificador de região da região

Gorjeta

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

Importante

Lembre-se de remover a chave do seu código quando terminar e nunca publicá-la publicamente. Para produção, use uma maneira segura de armazenar e acessar suas credenciais, como o Azure Key Vault. Consulte o artigo de segurança dos 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")

Este exemplo constrói o objeto usando a chave e a SpeechConfig região LUIS. Para obter uma lista completa dos métodos disponíveis, consulte SpeechConfig Class.

O SDK de Fala assumirá como padrão o reconhecimento usando en-us para o idioma, consulte Como reconhecer fala para obter informações sobre como escolher o idioma de origem.

Inicializar um IntentRecognizer

Agora, vamos criar um IntentRecognizerarquivo . Insira este código logo abaixo da sua configuração de Fala.

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

Adicionar um LanguageUnderstandingModel e intenções

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

Insira este código abaixo do seu IntentRecognizerarquivo . Certifique-se de que substitui "YourLanguageUnderstandingAppId" pelo ID da aplicação LUIS.

Gorjeta

Se precisar de ajuda para encontrar esse valor, consulte 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)

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

Reconhecer uma intenção

A partir do IntentRecognizer objeto, você vai chamar o recognize_once() método. Esse método permite que o serviço de Fala saiba que você está enviando uma única frase para reconhecimento e que, uma vez identificada a frase, pare de reconhecer a fala.

Insira este código abaixo do seu modelo.

intent_result = intent_recognizer.recognize_once()

Exibir os resultados (ou erros) de reconhecimento

Quando o resultado do reconhecimento é retornado pelo serviço de fala, você vai querer fazer algo com ele. Vamos simplificá-lo e imprimir o resultado para console.

Abaixo da sua 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))

Verifique o seu código

Neste ponto, seu código deve ter esta aparência.

Nota

Adicionámos 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>

Crie e execute seu aplicativo

Execute o exemplo a partir do console ou no IDE:

python quickstart.py

Os próximos 15 segundos de entrada de voz do microfone serão reconhecidos e registados na janela da consola.

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

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

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

O SDK de Fala para Objective-C suporta reconhecimento de intenção, mas ainda não incluímos um guia aqui. Selecione outra linguagem de programação para começar e aprender sobre os conceitos, ou veja a referência Objective-C e exemplos vinculados desde o início deste artigo.

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

O SDK de fala para Swift suporta reconhecimento de intenção, mas ainda não incluímos um guia aqui. Selecione outra linguagem de programação para começar e aprender sobre os conceitos, ou veja a referência Swift e exemplos vinculados desde o início deste artigo.

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

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

A interface de linha de comando de fala (CLI) suporta reconhecimento de intenção, mas ainda não incluímos um guia aqui. Selecione outra linguagem de programação para começar e aprender sobre os conceitos, ou consulte Visão geral da CLI de fala para obter mais informações sobre a CLI.

Próximos passos

Veja mais exemplos de LUIS no GitHub