Guia de início rápido: bibliotecas de cliente LUIS (Language Understanding) e API REST

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

• Criar uma aplicação
• Adicione uma intenção, uma entidade aprendida por máquina, com um enunciado de exemplo
• Treinar e publicar aplicativo
• Runtime de predição da consulta

Documentação | de referência Código fonte da Biblioteca de Criação e Previsão | Criação e previsão NuGet | Exemplo de C#

Pré-requisitos

• A versão atual do .NET Core e da CLI do .NET Core.
• Subscrição do Azure - Criar uma gratuitamente
• Depois de ter sua assinatura do Azure, crie um recurso de criação de Compreensão de Idioma no portal do Azure para obter sua chave e ponto de extremidade. Aguarde a implantação e clique no botão Ir para recurso.
  • Você precisará da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo à criação do Language Understanding. Você colará sua chave e ponto de extremidade no código abaixo mais adiante no início rápido. Você pode usar o nível de preço gratuito (F0) para experimentar o serviço.

Configuração

Criar um novo aplicativo C#

Crie um novo aplicativo .NET Core em seu editor ou IDE preferido.

1. Em uma janela de console (como cmd, PowerShell ou Bash), use o comando dotnet new para criar um novo aplicativo de console com o nome language-understanding-quickstart. Este comando cria um projeto C# "Hello World" simples com um único arquivo de origem: Program.cs.

   dotnet new console -n language-understanding-quickstart
   

2. Altere seu diretório para a pasta do aplicativo recém-criada.

   cd language-understanding-quickstart
   

3. Você pode criar o aplicativo com:

   dotnet build
   

   A saída da compilação não deve conter avisos ou erros.

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

Instalar as bibliotecas do NuGet

Dentro do diretório do aplicativo, instale as bibliotecas de cliente LUIS (Language Understanding) 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 Language Understanding (LUIS) é um objeto LUISAuthoringClient que se autentica no Azure, que contém sua chave de criação.

Exemplos de código para criação

Depois que o cliente for criado, use esse cliente para acessar a funcionalidade, incluindo:

• Aplicações - criar, eliminar, publicar
• Exemplos de enunciados - adicionar, excluir por ID
• Recursos - gerenciar listas de frases
• Modelo - gerenciar intenções e entidades
• Padrão - gerenciar padrões
• Treinar - treine o aplicativo e a pesquisa para obter o status do treinamento
• Versões - gerencie com clone, exporte e exclua

Modelo de objeto de previsão

O cliente de tempo de execução de previsão de Compreensão de Linguagem (LUIS) é um objeto LUISRuntimeClient que se autentica no Azure, que contém sua chave de recurso.

Exemplos de código para tempo de execução de previsão

Depois que o cliente for criado, use esse cliente para acessar a funcionalidade, incluindo:

• Previsão por preparo ou slot de produção
• Previsão por versão

Exemplos de código

Esses trechos de código mostram como fazer o seguinte com a biblioteca de cliente Language Understanding (LUIS) para python:

• Criar uma aplicação
• Adicionar intenção
• Adicionar entidades
• Adicionar exemplos de enunciados
• Treinar o aplicativo
• Publicar o aplicativo
• Previsão por slot

Adicionar as dependências

No diretório do projeto, abra o arquivo Program.cs em 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 clichê

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

   public static async Task Main()
   

2. Adicione o restante do código no Main método da classe, a Program menos que especificado de outra forma.

Criar variáveis para o aplicativo

Crie dois conjuntos de variáveis: o primeiro conjunto que você altera, o segundo conjunto deixa como aparecem no exemplo de código.

1. Crie variáveis para manter sua chave de criação e nomes de 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 manter seus pontos de extremidade, nome do aplicativo, versão e nome de intenção.

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

Autenticar o cliente

Crie um objeto ApiKeyServiceClientCredentials com sua chave e use-o com seu ponto de extremidade 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

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

Crie um ApplicationCreateObject. O nome e a cultura do idioma são propriedades obrigatórias. Chame o método Apps.AddAsync . A resposta é o ID do aplicativo.

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

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

Criar intenção para o aplicativo

O objeto principal no modelo de um aplicativo LUIS é a intenção. A intenção se alinha a um agrupamento de intenções de enunciação do usuário. Um usuário pode fazer uma pergunta ou fazer uma declaração procurando uma resposta pretendida específica de um bot (ou outro aplicativo cliente). Exemplos de intenções são reservar um voo, perguntar sobre o clima em uma cidade de destino e perguntar sobre informações de contato para atendimento ao cliente.

Crie um ModelCreateObject com o nome da intenção exclusiva e, em seguida, passe a ID do aplicativo, a ID da versão e o ModelCreateObject para o método Model.AddIntentAsync . A resposta é o ID de intenção.

O intentName valor é codificado como OrderPizzaIntent parte das variáveis na seção Criar variáveis para o aplicativo .

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

Criar entidades para o aplicativo

Embora as entidades não sejam necessárias, elas são encontradas na maioria dos aplicativos. A entidade extrai informações do enunciado do usuário, necessárias para completar a intenção do usuário. Existem vários tipos de entidades pré-criadas e personalizadas, cada uma com seus próprios modelos de objeto de transformação de dados (DTO). As entidades pré-criadas comuns a serem adicionadas ao seu aplicativo incluem number, datetimeV2, geographyV2, ordinal.

É importante saber que as entidades não são marcadas com uma intenção. Eles podem e geralmente se aplicam a muitas intenções. Somente os enunciados de usuário de exemplo são marcados para uma intenção única específica.

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

O código de criação de entidade cria uma entidade de aprendizado de máquina com subentidades e recursos aplicados à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" });

Use o seguinte método para a classe para localizar a ID da subentidade Quantity, a fim de atribuir os recursos 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 exemplo de enunciado à intenção

Para determinar a intenção de um enunciado e extrair entidades, o aplicativo precisa de exemplos de enunciados. Os exemplos precisam ter como alvo uma intenção única específica e devem marcar todas as entidades personalizadas. As entidades pré-construídas não precisam ser marcadas.

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

Chame Examples.AddAsync com a ID do aplicativo, a 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

Uma vez que o modelo é criado, o aplicativo LUIS precisa ser treinado para esta versão do modelo. Um modelo treinado pode ser usado em um contêiner ou publicado nos slots de preparo ou produto.

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

Um modelo muito pequeno, como este guia de arranque rápido, treinará muito rapidamente. Para aplicativos de nível de produção, o treinamento do aplicativo deve incluir uma chamada de sondagem para o método GetStatusAsync para determinar quando ou se o treinamento foi bem-sucedido. A resposta é uma lista de objetos ModelTrainingInfo com um status separado para cada objeto. Todos os objetos devem ser bem-sucedidos para que o treinamento seja considerado completo.

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 aplicativo no slot de produção

Publique o aplicativo LUIS usando o método PublishAsync . Isso publica a versão treinada atual no slot especificado no ponto de extremidade. Seu aplicativo cliente usa esse ponto de extremidade para enviar declarações do usuário para previsão de intenção e extração de entidade.

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

Autenticar o cliente de tempo de execução de previsão

Use um objeto ApiKeyServiceClientCredentials com sua chave e use-o com seu ponto de extremidade para criar um objeto LUISRuntimeClient .

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

Obter previsão do tempo de execução

Adicione o código a seguir para criar a solicitação ao tempo de execução de previsão.

O enunciado do usuário faz parte do objeto PredictionRequest .

O método GetSlotPredictionAsync precisa de vários parâmetros, como a ID do aplicativo, o nome do slot, o objeto de solicitação de previsão para atender à solicitação. As outras opções, como detalhada, mostrar todas as intenções e registrar 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 previsã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 o aplicativo com o dotnet run comando do diretório do aplicativo.

dotnet run

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

• Criar uma aplicação
• Adicione uma intenção, uma entidade aprendida por máquina, com um enunciado de exemplo
• Treinar e publicar aplicativo
• Runtime de predição da consulta

Documentação | de referência Criação e previsão NPM | Amostras

Pré-requisitos

• Node.js
• Subscrição do Azure - Criar uma gratuitamente
• Depois de ter sua assinatura do Azure, crie um recurso de criação de Compreensão de Idioma no portal do Azure para obter sua chave e ponto de extremidade. Aguarde a implantação e clique no botão Ir para recurso.
  • Você precisará da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo à criação do Language Understanding. Você colará sua chave e ponto de extremidade no código abaixo mais adiante no início rápido. Você pode usar o nível de preço gratuito (F0) para experimentar o serviço.

Configuração

Criar um novo aplicativo JavaScript

1. Em uma janela do console, crie um novo diretório para seu aplicativo e mova para esse diretório.

   mkdir quickstart-sdk && cd quickstart-sdk
   

2. Inicialize o diretório como um aplicativo JavaScript criando um package.json arquivo.

   npm init -y
   

3. Crie um arquivo com o nome index.js do seu código JavaScript.

   touch index.js
   

Instalar as bibliotecas do NPM

Dentro do diretório do aplicativo, 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

O seu package.json deve ter a seguinte aparência:

{
  "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 Language Understanding (LUIS) é um objeto LUISAuthoringClient que se autentica no Azure, que contém sua chave de criação.

Exemplos de código para criação

Depois que o cliente for criado, use esse cliente para acessar a funcionalidade, incluindo:

• Aplicações - adicionar, eliminar, publicar
• Exemplos de enunciados - adicionar por lote, excluir por ID
• Recursos - gerenciar listas de frases
• Modelo - gerenciar intenções e entidades
• Padrão - gerenciar padrões
• Treinar - treine o aplicativo e a pesquisa para obter o status do treinamento
• Versões - gerencie com clone, exporte e exclua

Modelo de objeto de previsão

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

Exemplos de código para tempo de execução de previsão

Depois que o cliente for criado, use esse cliente para acessar a funcionalidade, incluindo:

• Previsão por staging ou production slot
• Previsão por versão

Exemplos de código

Esses trechos de código mostram como fazer o seguinte com a biblioteca de cliente Language Understanding (LUIS) para python:

• Criar uma aplicação
• Adicionar intenção
• Adicionar entidades
• Adicionar exemplos de enunciados
• Treinar o aplicativo
• Publicar o aplicativo
• Previsão por slot

Adicionar as dependências

Abra o index.js arquivo em seu editor preferido ou IDE nomeado e 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 clichê

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

   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, a menos que especificado de outra forma.

Criar variáveis para o aplicativo

Crie dois conjuntos de variáveis: o primeiro conjunto que você altera, o segundo conjunto deixa como aparecem no exemplo de código.

1. Crie variáveis para manter sua chave de criação e 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 manter seus pontos de extremidade, nome do aplicativo, versão e nome de intenção.

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

Autenticar o cliente

Crie um objeto CognitiveServicesCredentials com sua chave e use-o com seu ponto de extremidade 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

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

Crie o método add de um objeto AppsOperation para criar o aplicativo. O nome e a cultura do idioma são propriedades obrigató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 o aplicativo

O objeto principal no modelo de um aplicativo LUIS é a intenção. A intenção está alinhada com um agrupamento de intenções de enunciação do usuário. Um usuário pode fazer uma pergunta ou fazer uma declaração procurando uma resposta pretendida específica de um bot (ou outro aplicativo cliente). Exemplos de intenções são reservar um voo, perguntar sobre o clima em uma cidade de destino e perguntar sobre informações de contato para atendimento ao cliente.

Use o método model.add_intent com o nome da intenção exclusiva e, em seguida, passe a ID do aplicativo, a ID da versão e o nome da nova intenção.

O intentName valor é codificado como OrderPizzaIntent parte das variáveis na seção Criar variáveis para o aplicativo .

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

Criar entidades para o aplicativo

Embora as entidades não sejam necessárias, elas são encontradas na maioria dos aplicativos. A entidade extrai informações do enunciado do usuário, necessárias para completar a intenção do usuário. Existem vários tipos de entidades pré-criadas e personalizadas, cada uma com seus próprios modelos de objeto de transformação de dados (DTO). As entidades pré-criadas comuns a serem adicionadas ao seu aplicativo incluem number, datetimeV2, geographyV2, ordinal.

É importante saber que as entidades não são marcadas com uma intenção. Eles podem e geralmente se aplicam a muitas intenções. Apenas expressões de usuário de exemplo são marcadas para uma intenção única específica.

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

O código de criação de entidade cria uma entidade de aprendizado de máquina com subentidades e recursos aplicados à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, a fim de atribuir os recursos a essa subentidade.

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

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

}

Adicionar exemplo de enunciado à intenção

Para determinar a intenção de um enunciado e extrair entidades, o aplicativo precisa de exemplos de enunciados. Os exemplos precisam ter como alvo uma intenção única específica e devem marcar todas as entidades personalizadas. As entidades pré-construídas não precisam ser marcadas.

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

Chame examples.add com o ID do aplicativo, 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

Uma vez que o modelo é criado, o aplicativo LUIS precisa ser treinado para esta versão do modelo. Um modelo treinado pode ser usado em um contêiner ou publicado nos slots de preparo ou produto.

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

Um modelo muito pequeno, como este guia de arranque rápido, treinará muito rapidamente. Para aplicativos de nível de produção, o treinamento do aplicativo deve incluir uma chamada de sondagem para o método get_status para determinar quando ou se o treinamento foi bem-sucedido. A resposta é uma lista de objetos ModelTrainingInfo com um status separado para cada objeto. Todos os objetos devem ser bem-sucedidos para que o treinamento seja considerado completo.

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 aplicativo no slot de produção

Publique o aplicativo LUIS usando o método app.publishing . Isso publica a versão treinada atual no slot especificado no ponto de extremidade. Seu aplicativo cliente usa esse ponto de extremidade para enviar declarações do usuário para previsão de intenção e extração de entidade.

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

Autenticar o cliente de tempo de execução de previsão

Use um msRest.ApiKeyCredentials objeto com sua chave e use-o com seu ponto de extremidade para criar um LUIS. Objeto LUISRuntimeClient .

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

Obter previsão do tempo de execução

Adicione o código a seguir para criar a solicitação ao tempo de execução de previsão. O enunciado do usuário faz parte do objeto predictionRequest.

O método luisRuntimeClient.prediction.getSlotPrediction precisa de vários parâmetros, como a ID do aplicativo, o nome do slot e o objeto de solicitação de previsão para atender à solicitação. As outras opções, como detalhada, mostrar todas as intenções e registrar 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 previsã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 node index.js no seu ficheiro de início rápido.

node index.js

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

• Criar uma aplicação
• Adicione uma intenção, uma entidade aprendida por máquina, com um enunciado de exemplo
• Treinar e publicar aplicativo
• Runtime de predição da consulta

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

Pré-requisitos

• A versão atual do Python 3.x.
• Subscrição do Azure - Criar uma gratuitamente
• Depois de ter sua assinatura do Azure, crie um recurso de criação de Compreensão de Idioma no portal do Azure para obter sua chave e ponto de extremidade. Aguarde a implantação e clique no botão Ir para recurso.
  • Você precisará da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo à criação do Language Understanding. Você colará sua chave e ponto de extremidade no código abaixo mais adiante no início rápido. Você pode usar o nível de preço gratuito (F0) para experimentar o serviço.

Configuração

Criar uma aplicação Python nova

1. Em uma janela do console, crie um novo diretório para seu aplicativo e mova para esse diretório.

   mkdir quickstart-sdk && cd quickstart-sdk
   

2. Crie um arquivo com o nome authoring_and_predict.py do seu código Python.

   touch authoring_and_predict.py
   

Instalar a biblioteca de cliente com Pip

Dentro do diretório do aplicativo, instale a biblioteca de cliente 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 Language Understanding (LUIS) é um objeto LUISAuthoringClient que se autentica no Azure, que contém sua chave de criação.

Exemplos de código para criação

Depois que o cliente for criado, use esse cliente para acessar a funcionalidade, incluindo:

• Aplicações - criar, eliminar, publicar
• Exemplos de enunciados - adicionar por lote, excluir por ID
• Recursos - gerenciar listas de frases
• Modelo - gerenciar intenções e entidades
• Padrão - gerenciar padrões
• Treinar - treine o aplicativo e a pesquisa para obter o status do treinamento
• Versões - gerencie com clone, exporte e exclua

Modelo de objeto de previsão

O cliente de tempo de execução de previsão de Compreensão de Linguagem (LUIS) é um objeto LUISRuntimeClient que se autentica no Azure, que contém sua chave de recurso.

Exemplos de código para tempo de execução de previsão

Depois que o cliente for criado, use esse cliente para acessar a funcionalidade, incluindo:

• Previsão por preparo ou slot de produção
• Previsão por versão

Exemplos de código

Esses trechos de código mostram como fazer o seguinte com a biblioteca de cliente Language Understanding (LUIS) para python:

• Criar uma aplicação
• Adicionar intenção
• Adicionar entidades
• Adicionar exemplos de enunciados
• Treinar o aplicativo
• Publicar o aplicativo
• Previsão por slot

Adicionar as dependências

Adicione as bibliotecas de cliente ao arquivo 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 clichê

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

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

2. Adicione o código restante no método de início rápido, a menos que especificado de outra forma.

Criar variáveis para o aplicativo

Crie dois conjuntos de variáveis: o primeiro conjunto que você altera, o segundo conjunto deixa como aparecem no exemplo de código.

1. Crie variáveis para manter sua chave de criação e nomes de 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 manter seus pontos de extremidade, nome do aplicativo, versão e nome de 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 sua chave e use-o com seu ponto de extremidade para criar um objeto LUISAuthoringClient .

client = LUISAuthoringClient(authoringEndpoint, CognitiveServicesCredentials(authoringKey))

Criar uma aplicação LUIS

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

Crie o método add de um objeto AppsOperation para criar o aplicativo. O nome e a cultura do idioma são propriedades obrigató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 o aplicativo

O objeto principal no modelo de um aplicativo LUIS é a intenção. A intenção está alinhada com um agrupamento de intenções de enunciação do usuário. Um usuário pode fazer uma pergunta ou fazer uma declaração procurando uma resposta pretendida específica de um bot (ou outro aplicativo cliente). Exemplos de intenções são reservar um voo, perguntar sobre o clima em uma cidade de destino e perguntar sobre informações de contato para atendimento ao cliente.

Use o método model.add_intent com o nome da intenção exclusiva e, em seguida, passe a ID do aplicativo, a ID da versão e o nome da nova intenção.

O intentName valor é codificado como OrderPizzaIntent parte das variáveis na seção Criar variáveis para o aplicativo .

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

Criar entidades para o aplicativo

Embora as entidades não sejam necessárias, elas são encontradas na maioria dos aplicativos. A entidade extrai informações do enunciado do usuário, necessárias para completar a intenção do usuário. Existem vários tipos de entidades pré-criadas e personalizadas, cada uma com seus próprios modelos de objeto de transformação de dados (DTO). As entidades pré-criadas comuns a serem adicionadas ao seu aplicativo incluem number, datetimeV2, geographyV2, ordinal.

É importante saber que as entidades não são marcadas com uma intenção. Eles podem e geralmente se aplicam a muitas intenções. Apenas expressões de usuário 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 seu próprio modelo de objeto de transformação de dados (DTO).

O código de criação de entidade cria uma entidade de aprendizado de máquina com subentidades e recursos aplicados à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, a fim de atribuir os recursos 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 exemplo de enunciado à intenção

Para determinar a intenção de um enunciado e extrair entidades, o aplicativo precisa de exemplos de enunciados. Os exemplos precisam ter como alvo uma intenção única específica e devem marcar todas as entidades personalizadas. As entidades pré-construídas não precisam ser marcadas.

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

Chame examples.add com o ID do aplicativo, 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

Uma vez que o modelo é criado, o aplicativo LUIS precisa ser treinado para esta versão do modelo. Um modelo treinado pode ser usado em um contêiner ou publicado nos slots de preparo ou produto.

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

Um modelo muito pequeno, como este guia de arranque rápido, treinará muito rapidamente. Para aplicativos de nível de produção, o treinamento do aplicativo deve incluir uma chamada de sondagem para o método get_status para determinar quando ou se o treinamento foi bem-sucedido. A resposta é uma lista de objetos ModelTrainingInfo com um status separado para cada objeto. Todos os objetos devem ser bem-sucedidos para que o treinamento seja considerado completo.

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 aplicativo no slot de produção

Publique o aplicativo LUIS usando o método app.publishing . Isso publica a versão treinada atual no slot especificado no ponto de extremidade. Seu aplicativo cliente usa esse ponto de extremidade para enviar declarações do usuário para previsão de intenção e extração de entidade.

# 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 tempo de execução de previsão

Use o objeto de credenciais com sua chave e use-o com seu ponto de extremidade para criar um objeto LUISRuntimeClientConfiguration .

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

Obter previsão do tempo de execução

Adicione o código a seguir para criar a solicitação ao tempo de execução de previsão.

O enunciado do usuário faz parte do objeto prediction_request .

O método get_slot_prediction precisa de vários parâmetros, como a ID do aplicativo, o nome do slot e o objeto de solicitação de previsão para atender à solicitação. As outras opções, como detalhada, mostrar todas as intenções e registrar são opcionais. A solicitação retorna 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 previsã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 python no seu ficheiro de início rápido.

python authoring_and_predict.py

Seguindo este início rápido, você executará três chamadas REST em sequência.

• Primeiro, você carregará um lote de expressões de exemplo, que serão usadas para treinar o modelo do aplicativo Pizza, usando a chamada REST Batch add labels .
• Em seguida, você começará uma sessão de treinamento para o aplicativo Pizza, usando a chamada de versão do aplicativo REST Train.
• Por fim, você obterá o status da sessão de treinamento para o aplicativo Pizza, usando a chamada de status de treinamento 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 comando cURL. O programa cURL já está instalado no macOS, na maioria das distribuições Linux e no Windows 10 build 1803 e posterior.

  Se você precisar instalar o cURL, você pode baixar o cURL na página de download do cURL.

Criar aplicativo Pizza

Crie o aplicativo de pizza.

1. Selecione pizza-app-for-luis-v6.json para abrir a página do GitHub para o pizza-app-for-luis.json arquivo.
2. Clique com o botão direito do mouse ou toque longamente no botão Raw e selecione Salvar link como para salvar o pizza-app-for-luis.json no seu computador.
3. Inicie sessão no portal LUIS.
4. Selecione Meus aplicativos.
5. Na página Meus Aplicativos, selecione + Novo aplicativo para conversa.
6. Selecione Importar como JSON.
7. Na caixa de diálogo Importar novo aplicativo, selecione o botão Escolher arquivo.
8. Selecione o ficheiro que pizza-app-for-luis.json transferiu e, em seguida, selecione Abrir.
9. No campo Nome da caixa de diálogo Importar novo aplicativo, insira um nome para o aplicativo Pizza e selecione o botão Concluído.

O aplicativo será importado.

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

Treine e publique o aplicativo Pizza

Você deve ver a página Intenções com uma lista das intenções no aplicativo Pizza.

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

   

2. O treinamento é concluído quando o botão Trem é desativado.

Para receber uma previsão LUIS em um bot de chat ou outros aplicativos cliente, você precisa publicar o aplicativo no ponto de extremidade de previsão.

1. Selecione Publicar na navegação no canto superior direito.

   

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

   

3. Selecione Acessar suas URLs de ponto de extremidade na notificação para ir para a página Recursos do Azure. Você só poderá ver as URLs se tiver um recurso de previsão associado ao aplicativo. Você também pode encontrar a página Recursos do Azure clicando em Gerenciar.

   

Adicionar um recurso de criação ao aplicativo Pizza

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

Se você tiver um recurso de criação, insira o Nome do locatário, o Nome da assinatura e o nome do recurso LUIS do recurso de criação.

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

1. Selecione Criar novo recurso.
2. Insira um Nome do Locatário, Nome do Recurso, Nome da Assinatura e Nome do Grupo de Recursos do Azure.

Seu aplicativo Pizza agora está pronto para uso.

Registre os valores de acesso para seu aplicativo Pizza

Para usar seu novo aplicativo Pizza, você precisará do ID do aplicativo, da chave de criação e do ponto de extremidade de criação do seu aplicativo Pizza. Para obter previsões, você precisará de seu ponto de extremidade de previsão separado e chave de previsão.

Para encontrar estes valores:

1. Na página Intenções, selecione GERENCIAR.
2. Na página Configurações do aplicativo, registre a ID do aplicativo.
3. Selecione Recursos do Azure.
4. Selecione Recurso de criação.
5. Nas guias Recurso de Criação e Recursos de Previsão, registre a Chave Primária. Este valor é a sua chave de criação.
6. Registre a URL do ponto de extremidade. Esse valor é seu ponto de extremidade de criação.

Criar um arquivo JSON para treinar o aplicativo Pizza

Para criar um arquivo JSON com três expressões de exemplo, salve os seguintes dados JSON em um arquivo chamado 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
      }
    ]
  }
]`

Os enunciados 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 você começar ou terminar o rótulo em um espaço no texto, a chamada da API para adicionar os enunciados 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
   • macOS
   • 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 pelos ***YOUR- seus próprios valores.

   Informação	Propósito
   ***YOUR-AUTHORING-ENDPOINT***	Seu ponto de extremidade de URL de criação. Por exemplo, "https://REPLACE-WITH-YOUR-RESOURCE-NAME.api.cognitive.microsoft.com/". Você define o nome do recurso quando o criou.
   ***YOUR-APP-ID***	O ID da sua aplicação LUIS.
   ***YOUR-APP-VERSION***	A sua versão da aplicação LUIS. Para o aplicativo Pizza, o número da versão é "0.1" sem as aspas.
   ***YOUR-AUTHORING-KEY***	Sua chave de criação de 32 caracteres.

   As chaves e os recursos atribuídos são visíveis no portal LUIS na seção Gerenciar, na página Recursos do Azure . O ID do aplicativo está disponível na mesma seção Gerenciar, na página Configurações do aplicativo.

   Importante

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

3. Inicie um prompt de comando (Windows) ou terminal (macOS e Linux) e altere os diretórios para o mesmo diretório onde você salvou o ExampleUtterances.JSON arquivo.

4. Copie o comando cURL do editor e cole-o em um prompt de comando (Windows) ou terminal (macOS e Linux). Pressione Enter para executar o comando.

   Você 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}]
   

   Aqui está a saída formatada 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
     }
   ]
   

Treinar o modelo do aplicativo Pizza

1. Para iniciar uma sessão de treinamento para o aplicativo Pizza, copie este comando para seu editor de texto:

   • Windows
   • macOS
   • 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. Como fez antes, substitua os valores que começam pelos ***YOUR- seus próprios valores.

3. Copie o comando cURL do editor e cole-o em um prompt de comando (Windows) ou terminal (macOS e Linux). Pressione Enter para executar o comando.

   Você verá a seguinte resposta:

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

   Aqui está a saída formatada para legibilidade:

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

Obter o status do treinamento

1. Para obter o status de treinamento para a sessão de treinamento, copie este comando no editor de texto:

   • Windows
   • macOS
   • 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. Como fez antes, substitua os valores que começam pelos ***YOUR- seus próprios valores.

3. Copie o comando cURL do editor e cole-o em um prompt de comando (Windows) ou terminal (macOS e Linux). Pressione Enter para executar o comando.

   Você 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}}]
   

   Aqui está a saída formatada 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 intenção a partir do ponto de extremidade de previsão

Use cURL para consultar o ponto de extremidade de previsão e obter um resultado de previsão.

1. Copie este comando para o editor de texto:

   • Windows
   • macOS
   • 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 pelos ***YOUR- seus próprios valores.

   Informação	Propósito
   ***YOUR-PREDICTION-ENDPOINT***	Seu ponto de extremidade de URL de previsão. Localizado no portal LUIS, página Recursos do Azure para seu aplicativo. Por exemplo, https://westus.api.cognitive.microsoft.com/.
   ***YOUR-APP-ID***	O ID do seu aplicativo. Localizado no portal LUIS, página Configurações do aplicativo para seu aplicativo.
   ***YOUR-PREDICTION-KEY***	Sua chave de previsão de 32 caracteres. Localizado no portal LUIS, página Recursos do Azure para seu aplicativo.

3. Copie o texto para uma janela do console e pressione Enter para executar o comando:

4. Analise a resposta da previsão, que é retornada 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"
               ]
             }
           ]
         }
       }
     }
   }