Início Rápido: bibliotecas de cliente Language Understanding (LUIS) e API REST

Importante

O LUIS será descontinuado a 1 de outubro de 2025 e a partir de 1 de abril de 2023 não poderá criar novos recursos do LUIS. Recomendamos que migre as suas aplicações LUIS para a compreensão de linguagem de conversação para beneficiar do suporte contínuo do produto e das capacidades multilingues.

Crie e consulte uma aplicação de inteligência artificial (IA) do Azure LUIS com as bibliotecas de cliente do SDK LUIS com este início rápido com C#, Python ou JavaScript. Também pode utilizar cURL para enviar pedidos com a API REST.

Language Understanding (LUIS) permite-lhe aplicar o processamento de linguagem natural (NLP) ao texto de linguagem natural e conversacional de um utilizador para prever o significado geral e extrair informações relevantes e detalhadas.

• A biblioteca de cliente de criação e a API REST permitem-lhe criar, editar, preparar e publicar a sua aplicação LUIS.
• A biblioteca de cliente runtime de predição e a API REST permitem-lhe consultar a aplicação publicada.

Utilize as bibliotecas de cliente Language Understanding (LUIS) para .NET para:

• Criar uma aplicação
• Adicionar uma intenção, uma entidade de aprendizagem automática, com uma expressão de exemplo
• Preparar e publicar aplicação
• Runtime de predição da consulta

Documentação de referência | Código fonte da Biblioteca de Criação e Predição | | NuGet de Criação e PrediçãoExemplo de C#

Pré-requisitos

• A versão atual da CLI .NET Core e .NET Core.
• Subscrição do Azure – Criar uma gratuitamente
• Assim que tiver a sua subscrição do Azure, crie um recurso de criação Language Understanding no portal do Azure para obter a sua chave e ponto final. Aguarde que seja implementado e clique no botão Ir para recurso .
  • Precisará da chave e do ponto final do recurso que criar para ligar a sua aplicação a Language Understanding criação. Irá colar a chave e o ponto final no código abaixo mais tarde no início rápido. Pode utilizar o escalão de preço gratuito (F0) para experimentar o serviço.

Configurar

Criar uma nova aplicação C#

Crie uma nova aplicação .NET Core no seu editor ou IDE preferido.

1. Numa janela da consola (como cmd, PowerShell ou Bash), utilize o comando dotnet new para criar uma nova aplicação de consola com o nome language-understanding-quickstart. Este comando cria um projeto C# "Hello World" simples com um único ficheiro de origem: Program.cs.

   dotnet new console -n language-understanding-quickstart
   

2. Altere o diretório para a pasta da aplicação recentemente criada.

   cd language-understanding-quickstart
   

3. Pode criar a aplicação com:

   dotnet build
   

   O resultado da compilação não deve conter avisos ou erros.

   ...
   Build succeeded.
    0 Warning(s)
    0 Error(s)
   ...
   

Instalar as bibliotecas NuGet

No diretório de aplicações, instale as bibliotecas de cliente Language Understanding (LUIS) para .NET com os seguintes comandos:

dotnet add package Microsoft.Azure.CognitiveServices.Language.LUIS.Authoring --version 3.2.0-preview.3
dotnet add package Microsoft.Azure.CognitiveServices.Language.LUIS.Runtime --version 3.1.0-preview.1

Modelo de Objeto de Criação

O cliente de criação do Language Understanding (LUIS) é um objeto LUISAuthoringClient que se autentica no Azure, que contém a sua chave de criação.

Exemplos de código para criação

Assim que o cliente for criado, utilize este cliente para aceder às funcionalidades, incluindo:

• Aplicações – criar, eliminar, publicar
• Expressões de exemplo – adicionar, eliminar por ID
• Funcionalidades – gerir listas de expressões
• Modelo – gerir intenções e entidades
• Padrão – gerir padrões
• Preparar - preparar a aplicação e o inquérito para o estado de formação
• Versões – gerir com clonagem, exportação e eliminação

Modelo de Objeto de Predição

O cliente de runtime de predição do Language Understanding (LUIS) é um objeto LUISRuntimeClient que se autentica no Azure, que contém a sua chave de recurso.

Exemplos de código para o runtime de predição

Assim que o cliente for criado, utilize este cliente para aceder às funcionalidades, incluindo:

• Predição por teste ou bloco de produção
• Predição por versão

Exemplos de código

Estes fragmentos de código mostram-lhe como fazer o seguinte com a biblioteca de cliente do Language Understanding (LUIS) para python:

• Criar uma aplicação
• Adicionar intenções
• Adicionar entidades
• Adicionar expressões de exemplo
• Preparar a aplicação
• Publicar a aplicação
• Predição por bloco

Adicionar as dependências

No diretório do projeto, abra o ficheiro Program.cs no seu editor ou IDE preferido. Substitua o código existente using pelas seguintes using diretivas:

using System;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.Azure.CognitiveServices.Language.LUIS.Authoring;
using Microsoft.Azure.CognitiveServices.Language.LUIS.Authoring.Models;
using Microsoft.Azure.CognitiveServices.Language.LUIS.Runtime;
using Microsoft.Azure.CognitiveServices.Language.LUIS.Runtime.Models;
using Newtonsoft.Json;

Adicionar código boilerplate

1. Altere a assinatura do Main método para permitir chamadas assíncronas:

   public static async Task Main()
   

2. Adicione o resto do código no Main método da Program classe, salvo especificação em contrário.

Criar variáveis para a aplicação

Crie dois conjuntos de variáveis: o primeiro conjunto que alterar, o segundo conjunto sai à medida que aparecem no exemplo de código.

Importante

Lembre-se de remover a chave do código quando terminar e nunca a publicar publicamente. Para produção, utilize uma forma segura de armazenar e aceder às suas credenciais, como o Azure Key Vault. Veja o artigo segurança dos Serviços Cognitivos para obter mais informações.

1. Crie variáveis para conter a chave de criação e os nomes dos recursos.

   var key = "PASTE_YOUR_LUIS_AUTHORING_SUBSCRIPTION_KEY_HERE";
   
   var authoringEndpoint = "PASTE_YOUR_LUIS_AUTHORING_ENDPOINT_HERE";
   var predictionEndpoint = "PASTE_YOUR_LUIS_PREDICTION_ENDPOINT_HERE";
   

2. Crie variáveis para conter os pontos finais, o nome da aplicação, a versão e o nome da intenção.

   var appName = "Contoso Pizza Company";
   var versionId = "0.1";
   var intentName = "OrderPizzaIntent";
   

Autenticar o cliente

Crie um objeto ApiKeyServiceClientCredentials com a sua chave e utilize-o com o ponto final para criar um objeto LUISAuthoringClient .

var credentials = new Microsoft.Azure.CognitiveServices.Language.LUIS.Authoring.ApiKeyServiceClientCredentials(key);
var client = new LUISAuthoringClient(credentials) { Endpoint = authoringEndpoint };

Criar uma aplicação LUIS

Uma aplicação LUIS contém o modelo de processamento de linguagem natural (NLP), incluindo intenções, entidades e expressões de exemplo.

Criar uma AplicaçãoCriarObjeto. As propriedades do nome e da cultura de idioma são necessárias. Chame o método Apps.AddAsync . A resposta é o ID da aplicação.

var newApp = new ApplicationCreateObject
{
    Culture = "en-us",
    Name = appName,
    InitialVersionId = versionId
};

var appId = await client.Apps.AddAsync(newApp);

Criar intenção para a aplicação

O objeto principal no modelo de uma aplicação LUIS é a intenção. A intenção alinha-se com um agrupamento de intenções de expressão de utilizador. Um utilizador pode fazer uma pergunta ou fazer uma declaração à procura de uma resposta específica a partir de um bot (ou de outra aplicação cliente). Exemplos de intenções são reservar um voo, perguntar sobre a meteorologia numa cidade de destino e perguntar sobre as informações de contacto para o atendimento ao cliente.

Crie um ModelCreateObject com o nome da intenção exclusiva e, em seguida, transmita o ID da aplicação, o ID da versão e o ModelCreateObject para o método Model.AddIntentAsync . A resposta é o ID da intenção.

O intentName valor é hard-coded para OrderPizzaIntent como parte das variáveis na secção Criar variáveis para a aplicação .

await client.Model.AddIntentAsync(appId, versionId, new ModelCreateObject()
{
    Name = intentName
});

Criar entidades para a aplicação

Embora as entidades não sejam necessárias, encontram-se na maioria das aplicações. A entidade extrai informações da expressão do utilizador, necessárias para filtrar totalmente a intenção do utilizador. Existem vários tipos de entidades pré-criadas e personalizadas, cada uma com os seus próprios modelos de objetos de transformação de dados (DTO). As entidades pré-criadas comuns a adicionar à sua aplicação incluem número, datetimeV2, geographyV2, ordinal.

É importante saber que as entidades não estão marcadas com uma intenção. Podem e geralmente aplicam-se a muitas intenções. Apenas as expressões de utilizador de exemplo são marcadas para uma intenção única específica.

Os métodos de criação para entidades fazem parte da classe Modelo . Cada tipo de entidade tem o seu próprio modelo de objeto de transformação de dados (DTO), normalmente contendo a palavra model no espaço de nomes Modelos .

O código de criação de entidades cria uma entidade de machine learning com subentidades e funcionalidades aplicadas às Quantity subentidades.

// Add Prebuilt entity
await client.Model.AddPrebuiltAsync(appId, versionId, new[] { "number" });

// Define ml entity with children and grandchildren
var mlEntityDefinition = new EntityModelCreateObject
{
    Name = "Pizza order",
    Children = new[]
    {
        new ChildEntityModelCreateObject
        {
            Name = "Pizza",
            Children = new[]
            {
                new ChildEntityModelCreateObject { Name = "Quantity" },
                new ChildEntityModelCreateObject { Name = "Type" },
                new ChildEntityModelCreateObject { Name = "Size" }
            }
        },
        new ChildEntityModelCreateObject
        {
            Name = "Toppings",
            Children = new[]
            {
                new ChildEntityModelCreateObject { Name = "Type" },
                new ChildEntityModelCreateObject { Name = "Quantity" }
            }
        }
    }
};

// Add ML entity 
var mlEntityId = await client.Model.AddEntityAsync(appId, versionId, mlEntityDefinition); ;

// Add phraselist feature
var phraselistId = await client.Features.AddPhraseListAsync(appId, versionId, new PhraselistCreateObject
{
    EnabledForAllModels = false,
    IsExchangeable = true,
    Name = "QuantityPhraselist",
    Phrases = "few,more,extra"
});

// Get entity and subentities
var model = await client.Model.GetEntityAsync(appId, versionId, mlEntityId);
var toppingQuantityId = GetModelGrandchild(model, "Toppings", "Quantity");
var pizzaQuantityId = GetModelGrandchild(model, "Pizza", "Quantity");

// add model as feature to subentity model
await client.Features.AddEntityFeatureAsync(appId, versionId, pizzaQuantityId, new ModelFeatureInformation { ModelName = "number", IsRequired = true });
await client.Features.AddEntityFeatureAsync(appId, versionId, toppingQuantityId, new ModelFeatureInformation { ModelName = "number"});

// add phrase list as feature to subentity model
await client.Features.AddEntityFeatureAsync(appId, versionId, toppingQuantityId, new ModelFeatureInformation { FeatureName = "QuantityPhraselist" });

Utilize o seguinte método para a classe para localizar o ID da subentidade Quantity, de modo a atribuir as funcionalidades a essa subentidade.

static Guid GetModelGrandchild(NDepthEntityExtractor model, string childName, string grandchildName)
{
    return model.Children.
        Single(c => c.Name == childName).
        Children.
        Single(c => c.Name == grandchildName).Id;
}

Adicionar expressão de exemplo à intenção

Para determinar a intenção de uma expressão e extrair entidades, a aplicação precisa de exemplos de expressões. Os exemplos têm de visar uma intenção única específica e devem marcar todas as entidades personalizadas. As entidades pré-criadas não precisam de ser marcadas.

Adicione expressões de exemplo ao criar uma lista de objetos ExampleLabelObject , um objeto para cada expressão de exemplo. Cada exemplo deve marcar todas as entidades com um dicionário de pares nome/valor de nome e valor de entidade. O valor da entidade deve ser exatamente como aparece no texto da expressão de exemplo.

Chame Examples.AddAsync com o ID da aplicação, o ID da versão e o exemplo.

// Define labeled example
var labeledExampleUtteranceWithMLEntity = new ExampleLabelObject
{
    Text = "I want two small seafood pizzas with extra cheese.",
    IntentName = intentName,
    EntityLabels = new[]
    {
        new EntityLabelObject
        {
            StartCharIndex = 7,
            EndCharIndex = 48,
            EntityName = "Pizza order",
            Children = new[]
            {
                new EntityLabelObject
                {
                    StartCharIndex = 7,
                    EndCharIndex = 30,
                    EntityName = "Pizza",
                    Children = new[]
                    {
                        new EntityLabelObject { StartCharIndex = 7, EndCharIndex = 9, EntityName = "Quantity" },
                        new EntityLabelObject { StartCharIndex = 11, EndCharIndex = 15, EntityName = "Size" },
                        new EntityLabelObject { StartCharIndex = 17, EndCharIndex = 23, EntityName = "Type" }
                    }
                },
                new EntityLabelObject
                {
                    StartCharIndex = 37,
                    EndCharIndex = 48,
                    EntityName = "Toppings",
                    Children = new[]
                    {
                        new EntityLabelObject { StartCharIndex = 37, EndCharIndex = 41, EntityName = "Quantity" },
                        new EntityLabelObject { StartCharIndex = 43, EndCharIndex = 48, EntityName = "Type" }
                    }
                }
            }
        },
    }
};

// Add an example for the entity.
// Enable nested children to allow using multiple models with the same name.
// The quantity subentity and the phraselist could have the same exact name if this is set to True
await client.Examples.AddAsync(appId, versionId, labeledExampleUtteranceWithMLEntity, enableNestedChildren: true); 

Preparar a aplicação

Assim que o modelo for criado, a aplicação LUIS tem de ser preparada para esta versão do modelo. Um modelo preparado pode ser utilizado num contentor ou publicado nos blocos de teste ou de produto.

O método Train.TrainVersionAsync precisa do ID da aplicação e do ID da versão.

Um modelo muito pequeno, como mostra este início rápido, será preparado muito rapidamente. Para aplicações ao nível da produção, a preparação da aplicação deve incluir uma chamada de consulta para o método GetStatusAsync para determinar quando ou se a preparação foi bem-sucedida. A resposta é uma lista de objetos ModelTrainingInfo com um estado separado para cada objeto. Todos os objetos têm de ser bem-sucedidos para que a preparação seja considerada concluída.

await client.Train.TrainVersionAsync(appId, versionId);
while (true)
{
    var status = await client.Train.GetStatusAsync(appId, versionId);
    if (status.All(m => m.Details.Status == "Success"))
    {
        // Assumes that we never fail, and that eventually we'll always succeed.
        break;
    }
}

Publicar aplicação no bloco de produção

Publique a aplicação LUIS com o método PublishAsync . Esta ação publica a versão preparada atual no bloco especificado no ponto final. A aplicação cliente utiliza este ponto final para enviar expressões de utilizador para predição de intenção e extração de entidades.

await client.Apps.PublishAsync(appId, new ApplicationPublishObject { VersionId = versionId, IsStaging=false});

Autenticar o cliente de runtime de predição

Utilize um objeto ApiKeyServiceClientCredentials com a sua chave e utilize-o com o ponto final para criar um objeto LUISRuntimeClient .

Atenção

Este início rápido utiliza a chave de criação como parte das credenciais de runtime. A chave de criação tem permissão para consultar o runtime com algumas consultas. Para código de teste e de nível de produção, substitua a chave de criação por uma chave de runtime de predição.

var runtimeClient = new LUISRuntimeClient(credentials) { Endpoint = predictionEndpoint };

Obter predição do runtime

Adicione o seguinte código para criar o pedido para o runtime de predição.

A expressão de utilizador faz parte do objeto PredictionRequest .

O método GetSlotPredictionAsync precisa de vários parâmetros, como o ID da aplicação, o nome do bloco, o objeto de pedido de predição para satisfazer o pedido. As outras opções, como verboso, mostrar todas as intenções e registo são opcionais.

// Production == slot name
var request = new PredictionRequest { Query = "I want two small pepperoni pizzas with more salsa" };
var prediction = await runtimeClient.Prediction.GetSlotPredictionAsync(appId, "Production", request);
Console.Write(JsonConvert.SerializeObject(prediction, Formatting.Indented));

A resposta de predição é um objeto JSON, incluindo a intenção e quaisquer entidades encontradas.

{
    "query": "I want two small pepperoni pizzas with more salsa",
    "prediction": {
        "topIntent": "OrderPizzaIntent",
        "intents": {
            "OrderPizzaIntent": {
                "score": 0.753606856
            },
            "None": {
                "score": 0.119097039
            }
        },
        "entities": {
            "Pizza order": [
                {
                    "Pizza": [
                        {
                            "Quantity": [
                                2
                            ],
                            "Type": [
                                "pepperoni"
                            ],
                            "Size": [
                                "small"
                            ],
                            "$instance": {
                                "Quantity": [
                                    {
                                        "type": "builtin.number",
                                        "text": "two",
                                        "startIndex": 7,
                                        "length": 3,
                                        "score": 0.968156934,
                                        "modelTypeId": 1,
                                        "modelType": "Entity Extractor",
                                        "recognitionSources": [
                                            "model"
                                        ]
                                    }
                                ],
                                "Type": [
                                    {
                                        "type": "Type",
                                        "text": "pepperoni",
                                        "startIndex": 17,
                                        "length": 9,
                                        "score": 0.9345611,
                                        "modelTypeId": 1,
                                        "modelType": "Entity Extractor",
                                        "recognitionSources": [
                                            "model"
                                        ]
                                    }
                                ],
                                "Size": [
                                    {
                                        "type": "Size",
                                        "text": "small",
                                        "startIndex": 11,
                                        "length": 5,
                                        "score": 0.9592077,
                                        "modelTypeId": 1,
                                        "modelType": "Entity Extractor",
                                        "recognitionSources": [
                                            "model"
                                        ]
                                    }
                                ]
                            }
                        }
                    ],
                    "Toppings": [
                        {
                            "Type": [
                                "salsa"
                            ],
                            "Quantity": [
                                "more"
                            ],
                            "$instance": {
                                "Type": [
                                    {
                                        "type": "Type",
                                        "text": "salsa",
                                        "startIndex": 44,
                                        "length": 5,
                                        "score": 0.7292897,
                                        "modelTypeId": 1,
                                        "modelType": "Entity Extractor",
                                        "recognitionSources": [
                                            "model"
                                        ]
                                    }
                                ],
                                "Quantity": [
                                    {
                                        "type": "Quantity",
                                        "text": "more",
                                        "startIndex": 39,
                                        "length": 4,
                                        "score": 0.9320932,
                                        "modelTypeId": 1,
                                        "modelType": "Entity Extractor",
                                        "recognitionSources": [
                                            "model"
                                        ]
                                    }
                                ]
                            }
                        }
                    ],
                    "$instance": {
                        "Pizza": [
                            {
                                "type": "Pizza",
                                "text": "two small pepperoni pizzas",
                                "startIndex": 7,
                                "length": 26,
                                "score": 0.812199831,
                                "modelTypeId": 1,
                                "modelType": "Entity Extractor",
                                "recognitionSources": [
                                    "model"
                                ]
                            }
                        ],
                        "Toppings": [
                            {
                                "type": "Toppings",
                                "text": "more salsa",
                                "startIndex": 39,
                                "length": 10,
                                "score": 0.7250252,
                                "modelTypeId": 1,
                                "modelType": "Entity Extractor",
                                "recognitionSources": [
                                    "model"
                                ]
                            }
                        ]
                    }
                }
            ],
            "$instance": {
                "Pizza order": [
                    {
                        "type": "Pizza order",
                        "text": "two small pepperoni pizzas with more salsa",
                        "startIndex": 7,
                        "length": 42,
                        "score": 0.769223332,
                        "modelTypeId": 1,
                        "modelType": "Entity Extractor",
                        "recognitionSources": [
                            "model"
                        ]
                    }
                ]
            }
        }
    }
}

Executar a aplicação

Execute a aplicação com o comando a dotnet run partir do diretório da aplicação.

dotnet run

Utilize as bibliotecas de cliente do Language Understanding (LUIS) para Node.js para:

• Criar uma aplicação
• Adicionar uma intenção, uma entidade de aprendizagem automática, com uma expressão de exemplo
• Preparar e publicar aplicação
• Runtime de predição da consulta

Documentação de referência | Código fonte da Biblioteca de Criação e Predição | | NPM de Criação e PrediçãoExemplos

Pré-requisitos

• Node.js
• Subscrição do Azure – Criar uma gratuitamente
• Assim que tiver a sua subscrição do Azure, crie um Language Understanding recurso de criação no portal do Azure para obter a chave e o ponto final. Aguarde pela implementação e clique no botão Ir para recurso .
  • Precisará da chave e do ponto final do recurso que criar para ligar a sua aplicação à criação de Language Understanding. Irá colar a chave e o ponto final no código abaixo mais tarde no início rápido. Pode utilizar o escalão de preço gratuito (F0) para experimentar o serviço.

Configurar

Criar uma nova aplicação JavaScript

1. Numa janela da consola, crie um novo diretório para a sua aplicação e mude para esse diretório.

   mkdir quickstart-sdk && cd quickstart-sdk
   

2. Inicialize o diretório como uma aplicação JavaScript ao criar um package.json ficheiro.

   npm init -y
   

3. Crie um ficheiro com o nome index.js para o seu código JavaScript.

   touch index.js
   

Instalar as bibliotecas NPM

No diretório da aplicação, instale as dependências com os seguintes comandos, executados uma linha de cada vez:

npm install @azure/ms-rest-js
npm install @azure/cognitiveservices-luis-authoring
npm install @azure/cognitiveservices-luis-runtime

Deverá package.json ter o seguinte aspeto:

{
  "name": "quickstart-sdk",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "@azure/cognitiveservices-luis-authoring": "^4.0.0-preview.3",
    "@azure/cognitiveservices-luis-runtime": "^5.0.0",
    "@azure/ms-rest-js": "^2.0.8"
  }
}

Modelo de Objeto de Criação

O cliente de criação do Language Understanding (LUIS) é um objeto LUISAuthoringClient que se autentica no Azure, que contém a sua chave de criação.

Exemplos de código para a criação

Assim que o cliente for criado, utilize este cliente para aceder à funcionalidade, incluindo:

• Aplicações – adicionar, eliminar, publicar
• Expressões de exemplo – adicionar por lote, eliminar por ID
• Funcionalidades – gerir listas de expressões
• Modelo – gerir intenções e entidades
• Padrão – gerir padrões
• Train - train the app and poll for training status (Preparar – preparar a aplicação e consultar o estado de preparação)
• Versões – gerir com clonagem, exportação e eliminação

Modelo de Objeto de Predição

O cliente de criação do Language Understanding (LUIS) é um objeto LUISAuthoringClient que se autentica no Azure, que contém a sua chave de criação.

Exemplos de código para o runtime de predição

Assim que o cliente for criado, utilize este cliente para aceder à funcionalidade, incluindo:

• Predição por staging ou production bloco
• Predição por versão

Exemplos de código

Estes fragmentos de código mostram-lhe como fazer o seguinte com a biblioteca de cliente do Language Understanding (LUIS) para python:

• Criar uma aplicação
• Adicionar intenções
• Adicionar entidades
• Adicionar expressões de exemplo
• Preparar a aplicação
• Publicar a aplicação
• Predição por bloco

Adicionar as dependências

Abra o index.js ficheiro no seu editor preferencial ou IDE com o nome e, em seguida, adicione as seguintes dependências.

const msRest = require("@azure/ms-rest-js");
const LUIS_Authoring = require("@azure/cognitiveservices-luis-authoring");
const LUIS_Prediction = require("@azure/cognitiveservices-luis-runtime");

Adicionar código automático

1. Adicione o quickstart método e a respetiva chamada. Este método contém a maior parte do código restante. Este método é chamado no final do ficheiro.

   const quickstart = async () => {
   
       // add calls here
   
   
   }
   quickstart()
       .then(result => console.log("Done"))
       .catch(err => {
           console.log(`Error: ${err}`)
           })
   

2. Adicione o código restante no método de início rápido, salvo especificação em contrário.

Criar variáveis para a aplicação

Crie dois conjuntos de variáveis: o primeiro conjunto que alterar, o segundo conjunto sai como aparecem no exemplo de código.

Importante

Lembre-se de remover a chave do código quando terminar e nunca a publicar publicamente. Para produção, utilize uma forma segura de armazenar e aceder às suas credenciais, como o Azure Key Vault. Veja o artigo Segurança dos Serviços Cognitivos para obter mais informações.

1. Crie variáveis para conter a chave de criação e os nomes de recursos.

   const authoringKey = 'PASTE_YOUR_LUIS_AUTHORING_SUBSCRIPTION_KEY_HERE';
   
   const authoringEndpoint = "PASTE_YOUR_LUIS_AUTHORING_ENDPOINT_HERE";
   const predictionEndpoint = "PASTE_YOUR_LUIS_PREDICTION_ENDPOINT_HERE";
   

2. Crie variáveis para conter os pontos finais, o nome da aplicação, a versão e o nome da intenção.

   const appName = "Contoso Pizza Company";
   const versionId = "0.1";
   const intentName = "OrderPizzaIntent";
   

Autenticar o cliente

Crie um objeto CognitiveServicesCredentials com a sua chave e utilize-o com o ponto final para criar um objeto LUISAuthoringClient .

const luisAuthoringCredentials = new msRest.ApiKeyCredentials({
    inHeader: { "Ocp-Apim-Subscription-Key": authoringKey }
});
const client = new LUIS_Authoring.LUISAuthoringClient(
    luisAuthoringCredentials,
    authoringEndpoint
);

Criar uma aplicação LUIS

Uma aplicação LUIS contém o modelo de processamento de linguagem natural (NLP), incluindo intenções, entidades e expressões de exemplo.

Crie um método de adição de objeto AppsOperation para criar a aplicação. O nome e a cultura de idioma são propriedades necessárias.

const create_app_payload = {
    name: appName,
    initialVersionId: versionId,
    culture: "en-us"
};

const createAppResult = await client.apps.add(
    create_app_payload
);

const appId = createAppResult.body

Criar intenção para a aplicação

O objeto principal no modelo de uma aplicação LUIS é a intenção. A intenção alinha-se com um agrupamento de intenções de expressão de utilizador. Um utilizador pode fazer uma pergunta ou fazer uma declaração à procura de uma resposta específica a partir de um bot (ou de outra aplicação cliente). Exemplos de intenções são reservar um voo, perguntar sobre a meteorologia numa cidade de destino e perguntar sobre as informações de contacto do suporte ao cliente.

Utilize o método model.add_intent com o nome da intenção exclusiva e, em seguida, transmita o ID da aplicação, o ID da versão e o novo nome da intenção.

O intentName valor é hard-coded para OrderPizzaIntent como parte das variáveis na secção Criar variáveis para a aplicação .

await client.model.addIntent(
    appId,
    versionId,
    { name: intentName }
);

Criar entidades para a aplicação

Embora as entidades não sejam necessárias, encontram-se na maioria das aplicações. A entidade extrai informações da expressão do utilizador, necessárias para filtrar na totalidade a intenção do utilizador. Existem vários tipos de entidades pré-criadas e personalizadas, cada uma com os seus próprios modelos de objetos de transformação de dados (DTO). As entidades pré-criadas comuns a adicionar à sua aplicação incluem número, datetimeV2, geographyV2, ordinal.

É importante saber que as entidades não estão marcadas com uma intenção. Podem e geralmente aplicam-se a muitas intenções. Apenas as expressões de utilizador de exemplo são marcadas para uma intenção única específica.

Os métodos de criação para entidades fazem parte da classe Modelo . Cada tipo de entidade tem o seu próprio modelo de objeto de transformação de dados (DTO).

O código de criação de entidades cria uma entidade de machine learning com subentidades e funcionalidades aplicadas às Quantity subentidades.

// Add Prebuilt entity
await client.model.addPrebuilt(appId, versionId, ["number"]);

// Define ml entity with children and grandchildren
const mlEntityDefinition = {
    name: "Pizza order",
    children: [
        {
            name: "Pizza",
            children: [
                { name: "Quantity" },
                { name: "Type" },
                { name: "Size" }
            ]
        },
        {
            name: "Toppings",
            children: [
                { name: "Type" },
                { name: "Quantity" }
            ]
        }
    ]
};

// Add ML entity 
const response = await client.model.addEntity(appId, versionId, mlEntityDefinition);
const mlEntityId = response.body;

// Add phraselist feature
const phraselistResponse = await client.features.addPhraseList(appId, versionId, {
    enabledForAllModels: false,
    isExchangeable: true,
    name: "QuantityPhraselist",
    phrases: "few,more,extra"
});
const phraseListId = phraselistResponse.body;

// Get entity and subentities
const model = await client.model.getEntity(appId, versionId, mlEntityId);
const toppingQuantityId = getModelGrandchild(model, "Toppings", "Quantity");
const pizzaQuantityId = getModelGrandchild(model, "Pizza", "Quantity");

// add model as feature to subentity model
await client.features.addEntityFeature(appId, versionId, pizzaQuantityId, { modelName: "number", isRequired: true });
await client.features.addEntityFeature(appId, versionId, toppingQuantityId, { modelName: "number" });

// add phrase list as feature to subentity model
await client.features.addEntityFeature(appId, versionId, toppingQuantityId, { featureName: "QuantityPhraselist" });

Coloque o seguinte método acima do quickstart método para localizar o ID da subentidade Quantity, de modo a atribuir as funcionalidades a essa subentidade.

const getModelGrandchild = (model, childName, grandchildName) => {

    return model.children.find(c => c.name == childName).children.find(c => c.name == grandchildName).id

}

Adicionar expressão de exemplo à intenção

Para determinar a intenção de uma expressão e extrair entidades, a aplicação precisa de exemplos de expressões. Os exemplos têm de visar uma intenção única específica e devem marcar todas as entidades personalizadas. As entidades pré-criadas não precisam de ser marcadas.

Adicione expressões de exemplo ao criar uma lista de objetos ExampleLabelObject , um objeto para cada expressão de exemplo. Cada exemplo deve marcar todas as entidades com um dicionário de pares nome/valor de nome e valor de entidade. O valor da entidade deve ser exatamente como aparece no texto da expressão de exemplo.

Chame examples.add com o ID da aplicação, o ID da versão e o exemplo.

// Define labeled example
const labeledExampleUtteranceWithMLEntity =
{
    text: "I want two small seafood pizzas with extra cheese.",
    intentName: intentName,
    entityLabels: [
        {
            startCharIndex: 7,
            endCharIndex: 48,
            entityName: "Pizza order",
            children: [
                {
                    startCharIndex: 7,
                    endCharIndex: 30,
                    entityName: "Pizza",
                    children: [
                        {
                            startCharIndex: 7,
                            endCharIndex: 9,
                            entityName: "Quantity"
                        },
                        {
                            startCharIndex: 11,
                            endCharIndex: 15,
                            entityName: "Size"
                        },
                        {
                            startCharIndex: 17,
                            endCharIndex: 23,
                            entityName: "Type"
                        }]
                },
                {
                    startCharIndex: 37,
                    endCharIndex: 48,
                    entityName: "Toppings",
                    children: [
                        {
                            startCharIndex: 37,
                            endCharIndex: 41,
                            entityName: "Quantity"
                        },
                        {
                            startCharIndex: 43,
                            endCharIndex: 48,
                            entityName: "Type"
                        }]
                }
            ]
        }
    ]
};

console.log("Labeled Example Utterance:", JSON.stringify(labeledExampleUtteranceWithMLEntity, null, 4 ));

// Add an example for the entity.
// Enable nested children to allow using multiple models with the same name.
// The quantity subentity and the phraselist could have the same exact name if this is set to True
await client.examples.add(appId, versionId, labeledExampleUtteranceWithMLEntity, { enableNestedChildren: true });

Preparar a aplicação

Assim que o modelo for criado, a aplicação LUIS tem de ser preparada para esta versão do modelo. Um modelo preparado pode ser utilizado num contentor ou publicado nos blocos de teste ou de produto.

O método train.trainVersion precisa do ID da aplicação e do ID da versão.

Um modelo muito pequeno, como mostra este início rápido, será preparado muito rapidamente. Para aplicações ao nível da produção, a preparação da aplicação deve incluir uma chamada de consulta para o método get_status para determinar quando ou se a preparação foi bem-sucedida. A resposta é uma lista de objetos ModelTrainingInfo com um estado separado para cada objeto. Todos os objetos têm de ser bem-sucedidos para que a preparação seja considerada concluída.

await client.train.trainVersion(appId, versionId);
while (true) {
    const status = await client.train.getStatus(appId, versionId);
    if (status.every(m => m.details.status == "Success")) {
        // Assumes that we never fail, and that eventually we'll always succeed.
        break;
    }
}

Publicar aplicação no bloco de produção

Publique a aplicação LUIS com o método app.publish . Esta ação publica a versão preparada atual no bloco especificado no ponto final. A aplicação cliente utiliza este ponto final para enviar expressões de utilizador para predição de intenção e extração de entidades.

await client.apps.publish(appId, { versionId: versionId, isStaging: false });

Autenticar o cliente de runtime de predição

Utilize um objeto msRest.ApiKeyCredentials com a sua chave e utilize-o com o ponto final para criar um LUIS. Objeto LUISRuntimeClient .

Atenção

Este início rápido utiliza a chave de criação como parte das credenciais de runtime. A chave de criação tem permissão para consultar o runtime com algumas consultas. Para código de teste e de nível de produção, substitua a chave de criação por uma chave de runtime de predição.

const luisPredictionClient = new LUIS_Prediction.LUISRuntimeClient(
    luisAuthoringCredentials,
    predictionEndpoint
);

Obter predição do runtime

Adicione o seguinte código para criar o pedido para o runtime de predição. A expressão de utilizador faz parte do objeto predictionRequest .

O método luisRuntimeClient.prediction.getSlotPrediction precisa de vários parâmetros, como o ID da aplicação, o nome do bloco e o objeto de pedido de predição para satisfazer o pedido. As outras opções, como verboso, mostrar todas as intenções e registo são opcionais.

// Production == slot name
const request = { query: "I want two small pepperoni pizzas with more salsa" };
const response = await luisPredictionClient.prediction.getSlotPrediction(appId, "Production", request);
console.log(JSON.stringify(response.prediction, null, 4 ));

A resposta de predição é um objeto JSON, incluindo a intenção e quaisquer entidades encontradas.

{
    "query": "I want two small pepperoni pizzas with more salsa",
    "prediction": {
        "topIntent": "OrderPizzaIntent",
        "intents": {
            "OrderPizzaIntent": {
                "score": 0.753606856
            },
            "None": {
                "score": 0.119097039
            }
        },
        "entities": {
            "Pizza order": [
                {
                    "Pizza": [
                        {
                            "Quantity": [
                                2
                            ],
                            "Type": [
                                "pepperoni"
                            ],
                            "Size": [
                                "small"
                            ],
                            "$instance": {
                                "Quantity": [
                                    {
                                        "type": "builtin.number",
                                        "text": "two",
                                        "startIndex": 7,
                                        "length": 3,
                                        "score": 0.968156934,
                                        "modelTypeId": 1,
                                        "modelType": "Entity Extractor",
                                        "recognitionSources": [
                                            "model"
                                        ]
                                    }
                                ],
                                "Type": [
                                    {
                                        "type": "Type",
                                        "text": "pepperoni",
                                        "startIndex": 17,
                                        "length": 9,
                                        "score": 0.9345611,
                                        "modelTypeId": 1,
                                        "modelType": "Entity Extractor",
                                        "recognitionSources": [
                                            "model"
                                        ]
                                    }
                                ],
                                "Size": [
                                    {
                                        "type": "Size",
                                        "text": "small",
                                        "startIndex": 11,
                                        "length": 5,
                                        "score": 0.9592077,
                                        "modelTypeId": 1,
                                        "modelType": "Entity Extractor",
                                        "recognitionSources": [
                                            "model"
                                        ]
                                    }
                                ]
                            }
                        }
                    ],
                    "Toppings": [
                        {
                            "Type": [
                                "salsa"
                            ],
                            "Quantity": [
                                "more"
                            ],
                            "$instance": {
                                "Type": [
                                    {
                                        "type": "Type",
                                        "text": "salsa",
                                        "startIndex": 44,
                                        "length": 5,
                                        "score": 0.7292897,
                                        "modelTypeId": 1,
                                        "modelType": "Entity Extractor",
                                        "recognitionSources": [
                                            "model"
                                        ]
                                    }
                                ],
                                "Quantity": [
                                    {
                                        "type": "Quantity",
                                        "text": "more",
                                        "startIndex": 39,
                                        "length": 4,
                                        "score": 0.9320932,
                                        "modelTypeId": 1,
                                        "modelType": "Entity Extractor",
                                        "recognitionSources": [
                                            "model"
                                        ]
                                    }
                                ]
                            }
                        }
                    ],
                    "$instance": {
                        "Pizza": [
                            {
                                "type": "Pizza",
                                "text": "two small pepperoni pizzas",
                                "startIndex": 7,
                                "length": 26,
                                "score": 0.812199831,
                                "modelTypeId": 1,
                                "modelType": "Entity Extractor",
                                "recognitionSources": [
                                    "model"
                                ]
                            }
                        ],
                        "Toppings": [
                            {
                                "type": "Toppings",
                                "text": "more salsa",
                                "startIndex": 39,
                                "length": 10,
                                "score": 0.7250252,
                                "modelTypeId": 1,
                                "modelType": "Entity Extractor",
                                "recognitionSources": [
                                    "model"
                                ]
                            }
                        ]
                    }
                }
            ],
            "$instance": {
                "Pizza order": [
                    {
                        "type": "Pizza order",
                        "text": "two small pepperoni pizzas with more salsa",
                        "startIndex": 7,
                        "length": 42,
                        "score": 0.769223332,
                        "modelTypeId": 1,
                        "modelType": "Entity Extractor",
                        "recognitionSources": [
                            "model"
                        ]
                    }
                ]
            }
        }
    }
}

Executar a aplicação

Execute a aplicação com o node index.js comando no ficheiro de início rápido.

node index.js

Utilize as bibliotecas de cliente do Language Understanding (LUIS) para Python para:

• Criar uma aplicação
• Adicionar uma intenção, uma entidade de aprendizagem automática, com uma expressão de exemplo
• Preparar e publicar aplicação
• Runtime de predição da consulta

Documentação de referência | Código fonte da Biblioteca de Criação e Predição | Pacote (Pypi) | Exemplos

Pré-requisitos

• A versão atual do Python 3.x.
• Subscrição do Azure – Criar uma gratuitamente
• Assim que tiver a sua subscrição do Azure, crie um Language Understanding recurso de criação no portal do Azure para obter a chave e o ponto final. Aguarde pela implementação e clique no botão Ir para recurso .
  • Precisará da chave e do ponto final do recurso que criar para ligar a sua aplicação à criação de Language Understanding. Irá colar a chave e o ponto final no código abaixo mais tarde no início rápido. Pode utilizar o escalão de preço gratuito (F0) para experimentar o serviço.

Configurar

Criar uma aplicação Python nova

1. Numa janela da consola, crie um novo diretório para a sua aplicação e mude para esse diretório.

   mkdir quickstart-sdk && cd quickstart-sdk
   

2. Crie um ficheiro com o nome authoring_and_predict.py para o seu código Python.

   touch authoring_and_predict.py
   

Instalar a biblioteca de cliente com o Pip

No diretório da aplicação, instale a biblioteca de cliente do Language Understanding (LUIS) para Python com o seguinte comando:

pip install azure-cognitiveservices-language-luis

Modelo de Objeto de Criação

O cliente de criação do Language Understanding (LUIS) é um objeto LUISAuthoringClient que se autentica no Azure, que contém a sua chave de criação.

Exemplos de código para a criação

Assim que o cliente for criado, utilize este cliente para aceder à funcionalidade, incluindo:

• Aplicações – criar, eliminar, publicar
• Expressões de exemplo – adicionar por lote, eliminar por ID
• Funcionalidades – gerir listas de expressões
• Modelo – gerir intenções e entidades
• Padrão – gerir padrões
• Train - train the app and poll for training status (Preparar – preparar a aplicação e consultar o estado de preparação)
• Versões – gerir com clonagem, exportação e eliminação

Modelo de Objeto de Predição

O cliente de runtime de predição do Language Understanding (LUIS) é um objeto LUISRuntimeClient que se autentica no Azure, que contém a sua chave de recurso.

Exemplos de código para o runtime de predição

Assim que o cliente for criado, utilize este cliente para aceder à funcionalidade, incluindo:

• Predição por teste ou bloco de produção
• Predição por versão

Exemplos de código

Estes fragmentos de código mostram-lhe como fazer o seguinte com a biblioteca de cliente do Language Understanding (LUIS) para python:

• Criar uma aplicação
• Adicionar intenções
• Adicionar entidades
• Adicionar expressões de exemplo
• Preparar a aplicação
• Publicar a aplicação
• Predição por bloco

Adicionar as dependências

Adicione as bibliotecas de cliente ao ficheiro Python.

from azure.cognitiveservices.language.luis.authoring import LUISAuthoringClient
from azure.cognitiveservices.language.luis.authoring.models import ApplicationCreateObject
from azure.cognitiveservices.language.luis.runtime import LUISRuntimeClient
from msrest.authentication import CognitiveServicesCredentials
from functools import reduce

import json, time, uuid

Adicionar código boilerplate

1. Adicione o quickstart método e a respetiva chamada. Este método contém a maior parte do código restante. Este método é chamado no final do ficheiro.

   def quickstart():
   
       # add calls here, remember to indent properly
   
   quickstart()
   

2. Adicione o código restante no método de início rápido, salvo especificação em contrário.

Criar variáveis para a aplicação

Crie dois conjuntos de variáveis: o primeiro conjunto que alterar, o segundo conjunto sai à medida que aparecem no exemplo de código.

Importante

Lembre-se de remover a chave do código quando terminar e nunca a publicar publicamente. Para produção, utilize uma forma segura de armazenar e aceder às suas credenciais, como o Azure Key Vault. Veja o artigo segurança dos Serviços Cognitivos para obter mais informações.

1. Crie variáveis para conter a chave de criação e os nomes dos recursos.

   authoringKey = 'PASTE_YOUR_LUIS_AUTHORING_SUBSCRIPTION_KEY_HERE'
   authoringEndpoint = 'PASTE_YOUR_LUIS_AUTHORING_ENDPOINT_HERE'
   predictionKey = 'PASTE_YOUR_LUIS_PREDICTION_SUBSCRIPTION_KEY_HERE'
   predictionEndpoint = 'PASTE_YOUR_LUIS_PREDICTION_ENDPOINT_HERE'
   

2. Crie variáveis para conter os pontos finais, o nome da aplicação, a versão e o nome da intenção.

   # We use a UUID to avoid name collisions.
   appName = "Contoso Pizza Company " + str(uuid.uuid4())
   versionId = "0.1"
   intentName = "OrderPizzaIntent"
   

Autenticar o cliente

Crie um objeto CognitiveServicesCredentials com a sua chave e utilize-o com o ponto final para criar um objeto LUISAuthoringClient .

client = LUISAuthoringClient(authoringEndpoint, CognitiveServicesCredentials(authoringKey))

Criar uma aplicação LUIS

Uma aplicação LUIS contém o modelo de processamento de linguagem natural (NLP), incluindo intenções, entidades e expressões de exemplo.

Crie o método de adição de um objeto AppsOperation para criar a aplicação. As propriedades do nome e da cultura de idioma são necessárias.

# define app basics
appDefinition = ApplicationCreateObject (name=appName, initial_version_id=versionId, culture='en-us')

# create app
app_id = client.apps.add(appDefinition)

# get app id - necessary for all other changes
print("Created LUIS app with ID {}".format(app_id))

Criar intenção para a aplicação

O objeto principal no modelo de uma aplicação LUIS é a intenção. A intenção alinha-se com um agrupamento de intenções de expressão de utilizador. Um utilizador pode fazer uma pergunta ou fazer uma declaração à procura de uma resposta específica a partir de um bot (ou de outra aplicação cliente). Exemplos de intenções são reservar um voo, perguntar sobre a meteorologia numa cidade de destino e perguntar sobre as informações de contacto para o atendimento ao cliente.

Utilize o método model.add_intent com o nome da intenção exclusiva e, em seguida, transmita o ID da aplicação, o ID da versão e o novo nome da intenção.

O intentName valor é hard-coded para OrderPizzaIntent como parte das variáveis na secção Criar variáveis para a aplicação .

client.model.add_intent(app_id, versionId, intentName)

Criar entidades para a aplicação

Embora as entidades não sejam necessárias, encontram-se na maioria das aplicações. A entidade extrai informações da expressão do utilizador, necessárias para filtrar totalmente a intenção do utilizador. Existem vários tipos de entidades pré-criadas e personalizadas, cada uma com os seus próprios modelos de objetos de transformação de dados (DTO). As entidades pré-criadas comuns a adicionar à sua aplicação incluem número, datetimeV2, geographyV2, ordinal.

É importante saber que as entidades não estão marcadas com uma intenção. Podem e geralmente aplicam-se a muitas intenções. Apenas as expressões de utilizador de exemplo são marcadas para uma intenção única específica.

Os métodos de criação para entidades fazem parte da classe ModelOperations . Cada tipo de entidade tem o seu próprio modelo de objeto de transformação de dados (DTO).

O código de criação de entidades cria uma entidade de machine learning com subentidades e funcionalidades aplicadas às Quantity subentidades.

# Add Prebuilt entity
client.model.add_prebuilt(app_id, versionId, prebuilt_extractor_names=["number"])

# define machine-learned entity
mlEntityDefinition = [
{
    "name": "Pizza",
    "children": [
        { "name": "Quantity" },
        { "name": "Type" },
        { "name": "Size" }
    ]
},
{
    "name": "Toppings",
    "children": [
        { "name": "Type" },
        { "name": "Quantity" }
    ]
}]

# add entity to app
modelId = client.model.add_entity(app_id, versionId, name="Pizza order", children=mlEntityDefinition)

# define phraselist - add phrases as significant vocabulary to app
phraseList = {
    "enabledForAllModels": False,
    "isExchangeable": True,
    "name": "QuantityPhraselist",
    "phrases": "few,more,extra"
}

# add phrase list to app
phraseListId = client.features.add_phrase_list(app_id, versionId, phraseList)

# Get entity and subentities
modelObject = client.model.get_entity(app_id, versionId, modelId)
toppingQuantityId = get_grandchild_id(modelObject, "Toppings", "Quantity")
pizzaQuantityId = get_grandchild_id(modelObject, "Pizza", "Quantity")

# add model as feature to subentity model
prebuiltFeatureRequiredDefinition = { "model_name": "number", "is_required": True }
client.features.add_entity_feature(app_id, versionId, pizzaQuantityId, prebuiltFeatureRequiredDefinition)

# add model as feature to subentity model
prebuiltFeatureNotRequiredDefinition = { "model_name": "number" }
client.features.add_entity_feature(app_id, versionId, toppingQuantityId, prebuiltFeatureNotRequiredDefinition)

# add phrase list as feature to subentity model
phraseListFeatureDefinition = { "feature_name": "QuantityPhraselist", "model_name": None }
client.features.add_entity_feature(app_id, versionId, toppingQuantityId, phraseListFeatureDefinition)

Coloque o seguinte método acima do quickstart método para localizar o ID da subentidade Quantity, de modo a atribuir as funcionalidades a essa subentidade.

def get_grandchild_id(model, childName, grandChildName):
    
    theseChildren = next(filter((lambda child: child.name == childName), model.children))
    theseGrandchildren = next(filter((lambda child: child.name == grandChildName), theseChildren.children))
    
    grandChildId = theseGrandchildren.id
    
    return grandChildId

Adicionar expressão de exemplo à intenção

Para determinar a intenção de uma expressão e extrair entidades, a aplicação precisa de exemplos de expressões. Os exemplos têm de visar uma intenção única específica e devem marcar todas as entidades personalizadas. As entidades pré-criadas não precisam de ser marcadas.

Adicione expressões de exemplo ao criar uma lista de objetos ExampleLabelObject , um objeto para cada expressão de exemplo. Cada exemplo deve marcar todas as entidades com um dicionário de pares nome/valor de nome/valor do nome da entidade e do valor da entidade. O valor da entidade deve ser exatamente como aparece no texto da expressão de exemplo.

Chame exemplos.add com o ID da aplicação, o ID da versão e o exemplo.

# Define labeled example
labeledExampleUtteranceWithMLEntity = {
    "text": "I want two small seafood pizzas with extra cheese.",
    "intentName": intentName,
    "entityLabels": [
        {
            "startCharIndex": 7,
            "endCharIndex": 48,
            "entityName": "Pizza order",
            "children": [
                {
                    "startCharIndex": 7,
                    "endCharIndex": 30,
                    "entityName": "Pizza",
                    "children": [
                        {
                            "startCharIndex": 7,
                            "endCharIndex": 9,
                            "entityName": "Quantity"
                        },
                        {
                            "startCharIndex": 11,
                            "endCharIndex": 15,
                            "entityName": "Size"
                        },
                        {
                            "startCharIndex": 17,
                            "endCharIndex": 23,
                            "entityName": "Type"
                        }]
                },
                {
                    "startCharIndex": 37,
                    "endCharIndex": 48,
                    "entityName": "Toppings",
                    "children": [
                        {
                            "startCharIndex": 37,
                            "endCharIndex": 41,
                            "entityName": "Quantity"
                        },
                        {
                            "startCharIndex": 43,
                            "endCharIndex": 48,
                            "entityName": "Type"
                        }]
                }
            ]
        }
    ]
}

print("Labeled Example Utterance:", labeledExampleUtteranceWithMLEntity)

# Add an example for the entity.
# Enable nested children to allow using multiple models with the same name.
# The quantity subentity and the phraselist could have the same exact name if this is set to True
client.examples.add(app_id, versionId, labeledExampleUtteranceWithMLEntity, { "enableNestedChildren": True })

Preparar a aplicação

Assim que o modelo for criado, a aplicação LUIS tem de ser preparada para esta versão do modelo. Um modelo preparado pode ser utilizado num contentor ou publicado nos blocos de teste ou de produto.

O método train.train_version precisa do ID da aplicação e do ID da versão.

Um modelo muito pequeno, como este guia de início rápido, irá preparar-se muito rapidamente. Para aplicações ao nível da produção, a preparação da aplicação deve incluir uma chamada de consulta para o método get_status para determinar quando ou se a formação foi bem-sucedida. A resposta é uma lista de objetos ModelTrainingInfo com um estado separado para cada objeto. Todos os objetos têm de ter êxito para que a preparação seja considerada concluída.

client.train.train_version(app_id, versionId)
waiting = True
while waiting:
    info = client.train.get_status(app_id, versionId)

    # get_status returns a list of training statuses, one for each model. Loop through them and make sure all are done.
    waiting = any(map(lambda x: 'Queued' == x.details.status or 'InProgress' == x.details.status, info))
    if waiting:
        print ("Waiting 10 seconds for training to complete...")
        time.sleep(10)
    else: 
        print ("trained")
        waiting = False

Publicar aplicação no bloco de produção

Publique a aplicação LUIS com o método app.publish . Esta ação publica a versão preparada atual no bloco especificado no ponto final. A aplicação cliente utiliza este ponto final para enviar expressões de utilizador para predição de intenção e extração de entidades.

# Mark the app as public so we can query it using any prediction endpoint.
# Note: For production scenarios, you should instead assign the app to your own LUIS prediction endpoint. See:
# https://docs.microsoft.com/en-gb/azure/cognitive-services/luis/luis-how-to-azure-subscription#assign-a-resource-to-an-app
client.apps.update_settings(app_id, is_public=True)

responseEndpointInfo = client.apps.publish(app_id, versionId, is_staging=False)

Autenticar o cliente de runtime de predição

Utilize o objeto de credenciais com a sua chave e utilize-o com o ponto final para criar um objeto LUISRuntimeClientConfiguration .

Atenção

Este início rápido utiliza a chave de criação como parte das credenciais de runtime. A chave de criação pode consultar o runtime com algumas consultas. Para código ao nível da produção e de teste, substitua a chave de criação por uma chave de runtime de predição.

runtimeCredentials = CognitiveServicesCredentials(predictionKey)
clientRuntime = LUISRuntimeClient(endpoint=predictionEndpoint, credentials=runtimeCredentials)

Obter predição a partir do runtime

Adicione o seguinte código para criar o pedido para o runtime de predição.

A expressão de utilizador faz parte do objeto prediction_request .

O método get_slot_prediction precisa de vários parâmetros, como o ID da aplicação, o nome do bloco e o objeto de pedido de predição para satisfazer o pedido. As outras opções, como verboso, mostrar todas as intenções e registo são opcionais. O pedido devolve um objeto PredictionResponse .

# Production == slot name
predictionRequest = { "query" : "I want two small pepperoni pizzas with more salsa" }

predictionResponse = clientRuntime.prediction.get_slot_prediction(app_id, "Production", predictionRequest)
print("Top intent: {}".format(predictionResponse.prediction.top_intent))
print("Sentiment: {}".format (predictionResponse.prediction.sentiment))
print("Intents: ")

for intent in predictionResponse.prediction.intents:
    print("\t{}".format (json.dumps (intent)))
print("Entities: {}".format (predictionResponse.prediction.entities))

A resposta de predição é um objeto JSON, incluindo a intenção e quaisquer entidades encontradas.

{
    "query": "I want two small pepperoni pizzas with more salsa",
    "prediction": {
        "topIntent": "OrderPizzaIntent",
        "intents": {
            "OrderPizzaIntent": {
                "score": 0.753606856
            },
            "None": {
                "score": 0.119097039
            }
        },
        "entities": {
            "Pizza order": [
                {
                    "Pizza": [
                        {
                            "Quantity": [
                                2
                            ],
                            "Type": [
                                "pepperoni"
                            ],
                            "Size": [
                                "small"
                            ],
                            "$instance": {
                                "Quantity": [
                                    {
                                        "type": "builtin.number",
                                        "text": "two",
                                        "startIndex": 7,
                                        "length": 3,
                                        "score": 0.968156934,
                                        "modelTypeId": 1,
                                        "modelType": "Entity Extractor",
                                        "recognitionSources": [
                                            "model"
                                        ]
                                    }
                                ],
                                "Type": [
                                    {
                                        "type": "Type",
                                        "text": "pepperoni",
                                        "startIndex": 17,
                                        "length": 9,
                                        "score": 0.9345611,
                                        "modelTypeId": 1,
                                        "modelType": "Entity Extractor",
                                        "recognitionSources": [
                                            "model"
                                        ]
                                    }
                                ],
                                "Size": [
                                    {
                                        "type": "Size",
                                        "text": "small",
                                        "startIndex": 11,
                                        "length": 5,
                                        "score": 0.9592077,
                                        "modelTypeId": 1,
                                        "modelType": "Entity Extractor",
                                        "recognitionSources": [
                                            "model"
                                        ]
                                    }
                                ]
                            }
                        }
                    ],
                    "Toppings": [
                        {
                            "Type": [
                                "salsa"
                            ],
                            "Quantity": [
                                "more"
                            ],
                            "$instance": {
                                "Type": [
                                    {
                                        "type": "Type",
                                        "text": "salsa",
                                        "startIndex": 44,
                                        "length": 5,
                                        "score": 0.7292897,
                                        "modelTypeId": 1,
                                        "modelType": "Entity Extractor",
                                        "recognitionSources": [
                                            "model"
                                        ]
                                    }
                                ],
                                "Quantity": [
                                    {
                                        "type": "Quantity",
                                        "text": "more",
                                        "startIndex": 39,
                                        "length": 4,
                                        "score": 0.9320932,
                                        "modelTypeId": 1,
                                        "modelType": "Entity Extractor",
                                        "recognitionSources": [
                                            "model"
                                        ]
                                    }
                                ]
                            }
                        }
                    ],
                    "$instance": {
                        "Pizza": [
                            {
                                "type": "Pizza",
                                "text": "two small pepperoni pizzas",
                                "startIndex": 7,
                                "length": 26,
                                "score": 0.812199831,
                                "modelTypeId": 1,
                                "modelType": "Entity Extractor",
                                "recognitionSources": [
                                    "model"
                                ]
                            }
                        ],
                        "Toppings": [
                            {
                                "type": "Toppings",
                                "text": "more salsa",
                                "startIndex": 39,
                                "length": 10,
                                "score": 0.7250252,
                                "modelTypeId": 1,
                                "modelType": "Entity Extractor",
                                "recognitionSources": [
                                    "model"
                                ]
                            }
                        ]
                    }
                }
            ],
            "$instance": {
                "Pizza order": [
                    {
                        "type": "Pizza order",
                        "text": "two small pepperoni pizzas with more salsa",
                        "startIndex": 7,
                        "length": 42,
                        "score": 0.769223332,
                        "modelTypeId": 1,
                        "modelType": "Entity Extractor",
                        "recognitionSources": [
                            "model"
                        ]
                    }
                ]
            }
        }
    }
}

Executar a aplicação

Execute a aplicação com o python comando no ficheiro de início rápido.

python authoring_and_predict.py

Ao seguir este início rápido, irá realizar três chamadas REST em sequência.

• Primeiro, irá carregar um lote de expressões de exemplo que serão utilizadas para preparar o modelo da aplicação Pizza, utilizando a chamada adicionar etiquetas do REST Batch .
• Em seguida, iniciará uma sessão de formação para a aplicação Pizza, com a chamada da versão da aplicação REST Train .
• Por fim, obterá o estado da sessão de preparação para a aplicação Pizza, com a chamada de estado de preparação da versão REST Get .

Documentação de referência

Pré-requisitos

• Uma conta LUIS gratuita.

• Um editor de texto, como o Visual Studio Code.

• O programa de linha de comandos cURL. O programa cURL já está instalado no macOS, na maioria das distribuições do Linux e Windows 10 compilação 1803 e posterior.

  Se precisar de instalar o cURL, pode transferir cURL a partir da página de transferência cURL.

Criar aplicação Pizza

Crie a aplicação pizza.

1. Selecione pizza-app-for-luis-v6.json para apresentar a página do GitHub do pizza-app-for-luis.json ficheiro.
2. Clique com o botão direito do rato ou toque no botão Raw e selecione Guardar ligação como para guardar no pizza-app-for-luis.json seu computador.
3. Inicie sessão no portal do LUIS.
4. Selecione As Minhas Aplicações.
5. Na página As Minhas Aplicações, selecione + Nova aplicação para conversação.
6. Selecione Importar como JSON.
7. Na caixa de diálogo Importar nova aplicação , selecione o botão Escolher Ficheiro .
8. Selecione o pizza-app-for-luis.json ficheiro que transferiu e, em seguida, selecione Abrir.
9. No campo Nome da caixa de diálogo Importar nova aplicação, introduza um nome para a sua aplicação Pizza e, em seguida, selecione o botão Concluído.

A aplicação será importada.

Se vir uma caixa de diálogo Como criar uma aplicação LUIS eficaz, feche a caixa de diálogo.

Preparar e publicar a aplicação Pizza

Deverá ver a página Intenções com uma lista das intenções na aplicação Pizza.

1. No canto superior direito do site do LUIS, selecione o botão Preparar .

   

2. A preparação é concluída quando o botão Preparar está desativado.

Para receber uma predição do LUIS num chatbot ou noutras aplicações cliente, tem de publicar a aplicação no ponto final de predição.

1. Selecione Publicar no painel de navegação superior direito.

   

2. Selecione o bloco Produção e, em seguida, selecione Concluído.

   

3. Selecione Aceder aos URLs de ponto final na notificação para aceder à página Recursos do Azure . Só poderá ver os URLs se tiver um recurso de predição associado à aplicação. Também pode encontrar a página Recursos do Azure ao clicar em Gerir.

   

Adicionar um recurso de criação à aplicação Pizza

1. Selecione GERIR.
2. Selecione Recursos do Azure.
3. Selecione Recurso de Criação.
4. Selecione Alterar recurso de criação.

Se tiver um recurso de criação, introduza o Nome do Inquilino, o Nome da Subscrição e o nome do recurso luis do recurso de criação.

Se não tiver um recurso de criação:

1. Selecione Criar novo recurso.
2. Introduza um Nome de Inquilino, Nome do Recurso, Nome da Subscrição e Nome do Grupo de Recursos do Azure.

A sua aplicação Pizza está agora pronta a ser utilizada.

Registar os valores de acesso da sua aplicação Pizza

Para utilizar a sua nova aplicação Pizza, precisará do ID da aplicação, da chave de criação e do ponto final de criação da sua aplicação Pizza. Para obter predições, precisará do ponto final de predição e da chave de predição separados.

Para localizar estes valores:

1. Na página Intenções , selecione GERIR.
2. Na página Definições da Aplicação , registe o ID da Aplicação.
3. Selecione Recursos do Azure.
4. Selecione Recurso de Criação.
5. Nos separadores Recursos de Criação e Recursos de Predição , registe a Chave Primária. Este valor é a sua chave de criação.
6. Registe o URL do Ponto Final. Este valor é o ponto final de criação.

Criar um ficheiro JSON para preparar a aplicação Pizza

Para criar um ficheiro JSON com três expressões de exemplo, guarde os seguintes dados JSON num ficheiro com o nome ExampleUtterances.JSON:

[
  {
    "text": "order a pizza",
    "intentName": "ModifyOrder",
    "entityLabels": [
      {
        "entityName": "Order",
        "startCharIndex": 6,
        "endCharIndex": 12
      }
    ]
  },
  {
    "text": "order a large pepperoni pizza",
    "intentName": "ModifyOrder",
    "entityLabels": [
      {
        "entityName": "Order",
        "startCharIndex": 6,
        "endCharIndex": 28
      },
      {
        "entityName": "FullPizzaWithModifiers",
        "startCharIndex": 6,
        "endCharIndex": 28
      },
      {
        "entityName": "PizzaType",
        "startCharIndex": 14,
        "endCharIndex": 28
      },
      {
        "entityName": "Size",
        "startCharIndex": 8,
        "endCharIndex": 12
      }
    ]
  },
  {
    "text": "I want two large pepperoni pizzas on thin crust",
    "intentName": "ModifyOrder",
    "entityLabels": [
      {
        "entityName": "Order",
        "startCharIndex": 7,
        "endCharIndex": 46
      },
      {
        "entityName": "FullPizzaWithModifiers",
        "startCharIndex": 7,
        "endCharIndex": 46
      },
      {
        "entityName": "PizzaType",
        "startCharIndex": 17,
        "endCharIndex": 32
      },
      {
        "entityName": "Size",
        "startCharIndex": 11,
        "endCharIndex": 15
      },
      {
        "entityName": "Quantity",
        "startCharIndex": 7,
        "endCharIndex": 9
      },
      {
        "entityName": "Crust",
        "startCharIndex": 37,
        "endCharIndex": 46
      }
    ]
  }
]`

As expressões de exemplo JSON seguem um formato específico.

O campo text contém o texto da expressão de exemplo. O campo intentName tem de corresponder ao nome de uma intenção existente na aplicação LUIS. O campo entityLabels é obrigatório. Se não quiser etiquetar entidades, forneça uma matriz vazia.

Se a matriz entityLabels não estiver vazia, startCharIndex e endCharIndex têm de marcar a entidade referida no campo entityName. O índice é baseado em zero. Se iniciar ou terminar a etiqueta num espaço no texto, a chamada à API para adicionar as expressões falhará.

Adicionar expressões de exemplo

1. Para carregar o lote de expressões de exemplo, copie este comando para o editor de texto:

   Windows

   curl "***YOUR-AUTHORING-ENDPOINT***/luis/authoring/v3.0-preview/apps/***YOUR-APP-ID***/versions/***YOUR-APP-VERSION***/examples?verbose=true&show-all-intents=true" ^
         --request POST ^
         --header "Content-Type:application/json" ^
         --header "Ocp-Apim-Subscription-Key: ***YOUR-AUTHORING-KEY***" ^
         --data "@ExampleUtterances.JSON"
   

   macOS

   curl "***YOUR-AUTHORING-ENDPOINT***/luis/authoring/v3.0-preview/apps/***YOUR-APP-ID***/versions/***YOUR-APP-VERSION***/examples?verbose=true&show-all-intents=true" \
         --request POST \
         --header "Content-Type:application/json" \
         --header "Ocp-Apim-Subscription-Key: ***YOUR-AUTHORING-KEY***" \
         --data "@ExampleUtterances.JSON"
   

   Linux

   curl "***YOUR-AUTHORING-ENDPOINT***/luis/authoring/v3.0-preview/apps/***YOUR-APP-ID***/versions/***YOUR-APP-VERSION***/examples?verbose=true&show-all-intents=true" \
         --request POST \
         --header "Content-Type:application/json" \
         --header "Ocp-Apim-Subscription-Key: ***YOUR-AUTHORING-KEY***" \
         --data "@ExampleUtterances.JSON"
   

2. Substitua os valores que começam por pelos ***YOUR- seus próprios valores.

   Informações	Objetivo
   ***YOUR-AUTHORING-ENDPOINT***	O ponto final do URL de criação. Por exemplo, "https://REPLACE-WITH-YOUR-RESOURCE-NAME.api.cognitive.microsoft.com/". Defina o nome do recurso quando criou o recurso.
   ***YOUR-APP-ID***	O ID da aplicação LUIS.
   ***YOUR-APP-VERSION***	A versão da aplicação LUIS. Para a aplicação Pizza, o número da versão é "0.1" sem as aspas.
   ***YOUR-AUTHORING-KEY***	A chave de criação de 32 carateres.

   As chaves atribuídas e os recursos são visíveis no portal do LUIS na secção Gerir, na página recursos do Azure . O ID da aplicação está disponível na mesma secção Gerir, na página Definições da Aplicação .

   Importante

   Lembre-se de remover a chave do código quando terminar e nunca a publicar publicamente. Para produção, utilize uma forma segura de armazenar e aceder às suas credenciais, como o Azure Key Vault. Veja o artigo Segurança dos Serviços Cognitivos para obter mais informações.

3. Inicie uma Linha de Comandos (Windows) ou Terminal (macOS e Linux) e altere os diretórios para o mesmo diretório onde guardou o ExampleUtterances.JSON ficheiro.

4. Copie o comando cURL do editor e cole-o numa Linha de Comandos (Windows) ou terminal (macOS e Linux). Prima Enter para executar o comando .

   Deverá ver a seguinte resposta:

   [{"value":{"ExampleId":1255129706,"UtteranceText":"order a pizza"},"hasError":false},{"value":{"ExampleId":1255129707,"UtteranceText":"order a large pepperoni pizza"},"hasError":false},{"value":{"ExampleId":1255129708,"UtteranceText":"i want two large pepperoni pizzas on thin crust"},"hasError":false}]
   

   Eis o resultado formatado para legibilidade:

   [
     {
       "value": {
         "ExampleId": 1255129706,
         "UtteranceText": "order a pizza"
       },
       "hasError": false
     },
     {
       "value": {
         "ExampleId": 1255129707,
         "UtteranceText": "order a large pepperoni pizza"
       },
       "hasError": false
     },
     {
       "value": {
         "ExampleId": 1255129708,
         "UtteranceText": "i want two large pepperoni pizzas on thin crust"
       },
       "hasError": false
     }
   ]
   

Preparar o modelo da aplicação Pizza

1. Para iniciar uma sessão de formação para a aplicação Pizza, copie este comando para o seu editor de texto:

   Windows

   curl "***YOUR-AUTHORING-ENDPOINT***/luis/authoring/v3.0-preview/apps/***YOUR-APP-ID***/versions/***YOUR-APP-VERSION***/train?verbose=true&show-all-intents=true" ^
         --data "" ^
         --request POST ^
         --header "Content-Type:application/json" ^
         --header "Ocp-Apim-Subscription-Key: ***YOUR-AUTHORING-KEY***"
   

   macOS

   curl "***YOUR-AUTHORING-ENDPOINT***/luis/authoring/v3.0-preview/apps/***YOUR-APP-ID***/versions/***YOUR-APP-VERSION***/train?verbose=true&show-all-intents=true" \
         --data "" \
         --request POST \
         --header "Content-Type:application/json" \
         --header "Ocp-Apim-Subscription-Key: ***YOUR-AUTHORING-KEY***"
   

   Linux

   curl "***YOUR-AUTHORING-ENDPOINT***/luis/authoring/v3.0-preview/apps/***YOUR-APP-ID***/versions/***YOUR-APP-VERSION***/train?verbose=true&show-all-intents=true" \
         --data "" \
         --request POST \
         --header "Content-Type:application/json" \
         --header "Ocp-Apim-Subscription-Key: ***YOUR-AUTHORING-KEY***"
   

2. Tal como fez anteriormente, substitua os valores que começam por pelos ***YOUR- seus próprios valores.

3. Copie o comando cURL do editor e cole-o numa Linha de Comandos (Windows) ou terminal (macOS e Linux). Prima Enter para executar o comando .

   Deverá ver a seguinte resposta:

   {"statusId":2,"status":"UpToDate"}
   

   Eis o resultado formatado para legibilidade:

   {
     "statusId": 2,
     "status": "UpToDate"
   }
   

Obter o estado da preparação

1. Para obter o estado de preparação da sessão de preparação, copie este comando para o seu editor de texto:

   Windows

   curl "***YOUR-AUTHORING-ENDPOINT***/luis/authoring/v3.0-preview/apps/***YOUR-APP-ID***/versions/***YOUR-APP-VERSION***/train?verbose=true&show-all-intents=true" ^
           --request GET ^
           --header "Content-Type:application/json" ^
           --header "Ocp-Apim-Subscription-Key: ***YOUR-AUTHORING-KEY***"
   

   macOS

   curl "***YOUR-AUTHORING-ENDPOINT***/luis/authoring/v3.0-preview/apps/***YOUR-APP-ID***/versions/***YOUR-APP-VERSION***/train?verbose=true&show-all-intents=true" \
           --request GET \
           --header "Content-Type:application/json" \
           --header "Ocp-Apim-Subscription-Key: ***YOUR-AUTHORING-KEY***"
   

   Linux

   curl "***YOUR-AUTHORING-ENDPOINT***/luis/authoring/v3.0-preview/apps/***YOUR-APP-ID***/versions/***YOUR-APP-VERSION***/train?verbose=true&show-all-intents=true" \
           --request GET \
           --header "Content-Type:application/json" \
           --header "Ocp-Apim-Subscription-Key: ***YOUR-AUTHORING-KEY***"
   

2. Tal como fez anteriormente, substitua os valores que começam por pelos ***YOUR- seus próprios valores.

3. Copie o comando cURL do editor e cole-o numa Linha de Comandos (Windows) ou terminal (macOS e Linux). Prima Enter para executar o comando .

   Deverá ver a seguinte resposta:

   [{"modelId":"8eb7ad8f-5db5-4c28-819b-ca3905fffd80","details":{"statusId":2,"status":"UpToDate","exampleCount":171}},{"modelId":"6f53bc92-ae54-44ce-bc4e-010d1f8cfda0","details":{"statusId":2,"status":"UpToDate","exampleCount":171}},{"modelId":"6cb17888-ad6e-464c-82c0-d37fd1f2c4f8","details":{"statusId":2,"status":"UpToDate","exampleCount":171}},{"modelId":"a16fc4fd-1949-4e77-9de3-30369f16c3a5","details":{"statusId":2,"status":"UpToDate","exampleCount":171}},{"modelId":"6bacdb75-1889-4f93-8971-8c8995ff8960","details":{"statusId":2,"status":"UpToDate","exampleCount":171}},{"modelId":"be963f4c-4898-48d7-9eba-3c6af0867b9d","details":{"statusId":2,"status":"UpToDate","exampleCount":171}}]
   

   Eis o resultado formatado para legibilidade:

   [
     {
       "modelId": "8eb7ad8f-5db5-4c28-819b-ca3905fffd80",
       "details": {
         "statusId": 2,
         "status": "UpToDate",
         "exampleCount": 171
       }
     },
     {
       "modelId": "6f53bc92-ae54-44ce-bc4e-010d1f8cfda0",
       "details": {
         "statusId": 2,
         "status": "UpToDate",
         "exampleCount": 171
       }
     },
     {
       "modelId": "6cb17888-ad6e-464c-82c0-d37fd1f2c4f8",
       "details": {
         "statusId": 2,
         "status": "UpToDate",
         "exampleCount": 171
       }
     },
     {
       "modelId": "a16fc4fd-1949-4e77-9de3-30369f16c3a5",
       "details": {
         "statusId": 2,
         "status": "UpToDate",
         "exampleCount": 171
       }
     },
     {
       "modelId": "6bacdb75-1889-4f93-8971-8c8995ff8960",
       "details": {
         "statusId": 2,
         "status": "UpToDate",
         "exampleCount": 171
       }
     },
     {
       "modelId": "be963f4c-4898-48d7-9eba-3c6af0867b9d",
       "details": {
         "statusId": 2,
         "status": "UpToDate",
         "exampleCount": 171
       }
     }
   ]
   

Obter a intenção a partir do ponto final de predição

Utilize cURL para consultar o ponto final de predição e obter um resultado de predição.

Nota

Este comando utiliza o ponto final de predição.

1. Copie este comando para o editor de texto:

   Windows

   curl "https://***YOUR-PREDICTION-ENDPOINT***/luis/prediction/v3.0/apps/***YOUR-APP-ID***/slots/production/predict" ^
         --request GET ^
         --get ^
         --data "subscription-key=***YOUR-PREDICTION-KEY***" ^
         --data "verbose=true" ^
         --data "show-all-intents=true" ^
         --data-urlencode "query=I want two large pepperoni pizzas on thin crust please"
   

   macOS

   curl "https://***YOUR-PREDICTION-ENDPOINT***/luis/prediction/v3.0/apps/***YOUR-APP-ID***/slots/production/predict" \
         --request GET \
         --get \
         --data "subscription-key=***YOUR-PREDICTION-KEY***" \
         --data "verbose=true" \
         --data "show-all-intents=true" \
         --data-urlencode "query=I want two large pepperoni pizzas on thin crust please"
   

   Linux

   curl "https://***YOUR-PREDICTION-ENDPOINT***/luis/prediction/v3.0/apps/***YOUR-APP-ID***/slots/production/predict" \
         --request GET \
         --get \
         --data "subscription-key=***YOUR-PREDICTION-KEY***" \
         --data "verbose=true" \
         --data "show-all-intents=true" \
         --data-urlencode "query=I want two large pepperoni pizzas on thin crust please"
   

2. Substitua os valores que começam por pelos ***YOUR- seus próprios valores.

   Informações	Objetivo
   ***YOUR-PREDICTION-ENDPOINT***	O ponto final do URL de predição. Localizado no portal do LUIS, página Recursos do Azure para a sua aplicação. Por exemplo, https://westus.api.cognitive.microsoft.com/.
   ***YOUR-APP-ID***	O ID da aplicação. Localizado no portal do LUIS, página Definições da Aplicação para a sua aplicação.
   ***YOUR-PREDICTION-KEY***	A chave de predição de 32 carateres. Localizado no portal do LUIS, página Recursos do Azure para a sua aplicação.

3. Copie o texto para uma janela da consola e prima Enter para executar o comando:

4. Reveja a resposta de predição, que é devolvida como JSON:

   {"query":"I want two large pepperoni pizzas on thin crust please","prediction":{"topIntent":"ModifyOrder","intents":{"ModifyOrder":{"score":1.0},"None":{"score":8.55E-09},"Greetings":{"score":1.82222226E-09},"CancelOrder":{"score":1.47272727E-09},"Confirmation":{"score":9.8125E-10}},"entities":{"Order":[{"FullPizzaWithModifiers":[{"PizzaType":["pepperoni pizzas"],"Size":[["Large"]],"Quantity":[2],"Crust":[["Thin"]],"$instance":{"PizzaType":[{"type":"PizzaType","text":"pepperoni pizzas","startIndex":17,"length":16,"score":0.9978157,"modelTypeId":1,"modelType":"Entity Extractor","recognitionSources":["model"]}],"Size":[{"type":"SizeList","text":"large","startIndex":11,"length":5,"score":0.9984481,"modelTypeId":1,"modelType":"Entity Extractor","recognitionSources":["model"]}],"Quantity":[{"type":"builtin.number","text":"two","startIndex":7,"length":3,"score":0.999770939,"modelTypeId":1,"modelType":"Entity Extractor","recognitionSources":["model"]}],"Crust":[{"type":"CrustList","text":"thin crust","startIndex":37,"length":10,"score":0.933985531,"modelTypeId":1,"modelType":"Entity Extractor","recognitionSources":["model"]}]}}],"$instance":{"FullPizzaWithModifiers":[{"type":"FullPizzaWithModifiers","text":"two large pepperoni pizzas on thin crust","startIndex":7,"length":40,"score":0.90681237,"modelTypeId":1,"modelType":"Entity Extractor","recognitionSources":["model"]}]}}],"ToppingList":[["Pepperoni"]],"$instance":{"Order":[{"type":"Order","text":"two large pepperoni pizzas on thin crust","startIndex":7,"length":40,"score":0.9047088,"modelTypeId":1,"modelType":"Entity Extractor","recognitionSources":["model"]}],"ToppingList":[{"type":"ToppingList","text":"pepperoni","startIndex":17,"length":9,"modelTypeId":5,"modelType":"List Entity Extractor","recognitionSources":["model"]}]}}}}
   

   Resposta JSON formatada para legibilidade:

   {
     "query": "I want two large pepperoni pizzas on thin crust please",
     "prediction": {
       "topIntent": "ModifyOrder",
       "intents": {
         "ModifyOrder": {
           "score": 1.0
         },
         "None": {
           "score": 8.55e-9
         },
         "Greetings": {
           "score": 1.82222226e-9
         },
         "CancelOrder": {
           "score": 1.47272727e-9
         },
         "Confirmation": {
           "score": 9.8125e-10
         }
       },
       "entities": {
         "Order": [
           {
             "FullPizzaWithModifiers": [
               {
                 "PizzaType": [
                   "pepperoni pizzas"
                 ],
                 "Size": [
                   [
                     "Large"
                   ]
                 ],
                 "Quantity": [
                   2
                 ],
                 "Crust": [
                   [
                     "Thin"
                   ]
                 ],
                 "$instance": {
                   "PizzaType": [
                     {
                       "type": "PizzaType",
                       "text": "pepperoni pizzas",
                       "startIndex": 17,
                       "length": 16,
                       "score": 0.9978157,
                       "modelTypeId": 1,
                       "modelType": "Entity Extractor",
                       "recognitionSources": [
                         "model"
                       ]
                     }
                   ],
                   "Size": [
                     {
                       "type": "SizeList",
                       "text": "large",
                       "startIndex": 11,
                       "length": 5,
                       "score": 0.9984481,
                       "modelTypeId": 1,
                       "modelType": "Entity Extractor",
                       "recognitionSources": [
                         "model"
                       ]
                     }
                   ],
                   "Quantity": [
                     {
                       "type": "builtin.number",
                       "text": "two",
                       "startIndex": 7,
                       "length": 3,
                       "score": 0.999770939,
                       "modelTypeId": 1,
                       "modelType": "Entity Extractor",
                       "recognitionSources": [
                         "model"
                       ]
                     }
                   ],
                   "Crust": [
                     {
                       "type": "CrustList",
                       "text": "thin crust",
                       "startIndex": 37,
                       "length": 10,
                       "score": 0.933985531,
                       "modelTypeId": 1,
                       "modelType": "Entity Extractor",
                       "recognitionSources": [
                         "model"
                       ]
                     }
                   ]
                 }
               }
             ],
             "$instance": {
               "FullPizzaWithModifiers": [
                 {
                   "type": "FullPizzaWithModifiers",
                   "text": "two large pepperoni pizzas on thin crust",
                   "startIndex": 7,
                   "length": 40,
                   "score": 0.90681237,
                   "modelTypeId": 1,
                   "modelType": "Entity Extractor",
                   "recognitionSources": [
                     "model"
                   ]
                 }
               ]
             }
           }
         ],
         "ToppingList": [
           [
             "Pepperoni"
           ]
         ],
         "$instance": {
           "Order": [
             {
               "type": "Order",
               "text": "two large pepperoni pizzas on thin crust",
               "startIndex": 7,
               "length": 40,
               "score": 0.9047088,
               "modelTypeId": 1,
               "modelType": "Entity Extractor",
               "recognitionSources": [
                 "model"
               ]
             }
           ],
           "ToppingList": [
             {
               "type": "ToppingList",
               "text": "pepperoni",
               "startIndex": 17,
               "length": 9,
               "modelTypeId": 5,
               "modelType": "List Entity Extractor",
               "recognitionSources": [
                 "model"
               ]
             }
           ]
         }
       }
     }
   }
   

Limpar os recursos

Pode eliminar a aplicação do portal do LUIS e eliminar os recursos do Azure do portal do Azure.

Se estiver a utilizar a API REST, elimine o ExampleUtterances.JSON ficheiro do sistema de ficheiros quando terminar o início rápido.

Resolução de problemas

• Autenticação na biblioteca de cliente – os erros de autenticação normalmente indicam que o ponto final de chave & errado foi utilizado. Este início rápido utiliza a chave de criação e o ponto final para o runtime de predição como conveniência, mas só funcionará se ainda não tiver utilizado a quota mensal. Se não conseguir utilizar a chave de criação e o ponto final, terá de utilizar a chave de runtime de predição e o ponto final ao aceder à biblioteca de cliente do SDK do runtime de predição.
• Criar entidades – se receber um erro ao criar a entidade aninhada de machine learning utilizada neste tutorial, certifique-se de que copiou o código e não alterou o código para criar uma entidade diferente.
• Criar expressões de exemplo – se receber um erro ao criar a expressão de exemplo etiquetada utilizada neste tutorial, certifique-se de que copiou o código e não alterou o código para criar um exemplo etiquetado diferente.
• Formação – se receber um erro de preparação, normalmente indica uma aplicação vazia (sem intenções com expressões de exemplo) ou uma aplicação com intenções ou entidades mal formadas.
• Erros diversos – uma vez que o código chama as bibliotecas de cliente com texto e objetos JSON, certifique-se de que não alterou o código.

Outros erros – se receber um erro não abordado na lista anterior, informe-nos ao enviar feedback na parte inferior desta página. Inclua a linguagem de programação e a versão das bibliotecas de cliente que instalou.

Passos seguintes

• Desenvolvimento de aplicações iterativas para LUIS