Inicio rápido: API REST y bibliotecas cliente de Language Understanding (LUIS)

Importante

LUIS se retirará el 1 de octubre de 2025. Además, a partir del 1 de abril de 2023, ya no se podrán crear recursos de este servicio. Se recomienda migrar las aplicaciones de LUIS al reconocimiento del lenguaje conversacional para aprovechar el soporte continuo del producto y las capacidades multilingües.

Con este inicio rápido, creará una aplicación de inteligencia artificial de Azure LUIS, y realizará consultas en ella, con las bibliotecas cliente del SDK de LUIS mediante C#, Python o JavaScript. También puede usar cURL para enviar solicitudes mediante la API REST.

Language Understanding (LUIS) permite aplicar procesamiento del lenguaje natural a una conversación o un texto de lenguaje natural de un usuario para predecir el significado global y extraer información pertinente y detallada.

• La API REST y la biblioteca cliente de creación le permiten crear, editar, entrenar y publicar aplicaciones de LUIS.
• La API REST y la biblioteca cliente del runtime de predicción permiten consultar la aplicación publicada.

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

• Crear una aplicación.
• Agregar una intención, una entidad de aprendizaje automático, con una expresión de ejemplo
• Entrenamiento y publicación de la aplicación
• Consulta de runtime de predicción

Documentación de referencia | Código fuente de la biblioteca de creación y predicción | NuGet de creación y predicción | Ejemplo de C#

Requisitos previos

• La versión actual de .NET Core y de la CLI de .NET Core.
• Una suscripción a Azure: cree una cuenta gratuita
• Cuando tenga la suscripción a Azure, cree un recurso de creación de Language Understanding en Azure Portal para obtener la clave de creación y el punto de conexión. Espere a que se implemente y haga clic en el botón Ir al recurso.
  • Necesitará la clave y el punto de conexión del recurso que cree para conectar la aplicación a la creación de Language Understanding. En una sección posterior de este mismo inicio rápido pegará la clave y el punto de conexión en el código siguiente. Puede usar el plan de tarifa gratuito (F0) para probar el servicio.

Instalación

Creación de una aplicación de C#

Cree una nueva aplicación de consola de .NET Core en el IDE o editor que prefiera.

1. En una ventana de consola (por ejemplo, cmd, PowerShell o Bash), use el comando new dotnet para crear una nueva aplicación de consola con el nombre language-understanding-quickstart. Este comando crea un sencillo proyecto "Hola mundo" de C# con un solo archivo de origen: Program.cs.

   dotnet new console -n language-understanding-quickstart
   

2. Cambie el directorio a la carpeta de aplicaciones recién creada.

   cd language-understanding-quickstart
   

3. Para compilar la aplicación:

   dotnet build
   

   La salida de la compilación no debe contener advertencias ni errores.

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

Instalación de las bibliotecas de NuGet

En el directorio de la aplicación, instale las bibliotecas cliente de Language Understanding (LUIS) para .NET con los siguientes 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

Creación de un modelo de objetos

El cliente de creación de Language Understanding (LUIS) es un objeto LUISAuthoringClient que se autentica en Azure, que contiene la clave de creación.

Ejemplos de código para la creación

Una vez creado el cliente, úselo para acceder a la funcionalidad, entre la que se incluye:

• Aplicaciones: creación, eliminación, publicación
• Expresiones de ejemplo: adición y eliminación por identificador
• Características: administración de listas de frases
• Modelo: administración de intenciones y entidades
• Patrón: administración de patrones
• Entrenamiento: entrenamiento de la aplicación y sondeo del estado del entrenamiento
• Versiones: administración con clonación, exportación y eliminación

Modelo de objetos de predicción

El cliente del entorno de ejecución de predicción de Language Understanding (LUIS) es un objeto LUISRuntimeClient que se autentica en Azure, que contiene la clave del recurso.

Ejemplos de código para el entorno de ejecución de predicción

Una vez creado el cliente, úselo para acceder a la funcionalidad, entre la que se incluye:

• Predicción por almacenamiento provisional o espacio de producción
• Predicción por versión

Ejemplos de código

Estos fragmentos de código muestran cómo realizar las siguientes acciones con la biblioteca cliente de Language Understanding (LUIS) para Python:

• Creación de una aplicación
• Adición de intención
• Adición de entidades
• Add example utterances (Adición de expresiones de ejemplo)
• Entrenamiento de la aplicación
• Publicación de la aplicación
• Predicción por espacio

Adición de las dependencias

En el directorio del proyecto, abra el archivo Program.cs en el editor o IDE que prefiera. Reemplace el código existente using por las siguientes directivas using:

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;

Adición de código reutilizable

1. Cambie la firma del método Main para permitir las llamadas asincrónicas:

   public static async Task Main()
   

2. Agregue el resto del código del método Main de la clase Program, salvo que se especifique lo contrario.

Creación de variables para la aplicación

Cree dos conjuntos de variables: cambie el primer conjunto y el segundo déjelo como aparece en el ejemplo de código.

Importante

Recuerde quitar la clave del código cuando haya terminado y no hacerla nunca pública. En el caso de producción, use una forma segura de almacenar sus credenciales y acceder a ellas, como Azure Key Vault. Consulte el artículo Seguridad de servicios de Azure AI para más información.

1. Cree variables para almacenar la clave de creación y los nombres 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. Cree variables para almacenar los puntos de conexión, el nombre de la aplicación, su versión y el nombre de la intención.

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

Autenticar el cliente

Cree un objeto ApiKeyServiceClientCredentials con la clave y úselo con el punto de conexión para crear un objeto LUISAuthoringClient.

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

Creación de una aplicación de LUIS

Las aplicaciones de LUIS contienen el modelo de procesamiento de lenguaje natural (NLP), que incluye intenciones, entidades y expresiones de ejemplo.

Cree un elemento ApplicationCreateObject. El nombre y la referencia cultural del idioma son propiedades necesarias. Llame al método Apps.AddAsync. La respuesta es el id. de la aplicación.

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

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

Creación de una intención para la aplicación

El objeto principal en el modelo de una aplicación LUIS es la intención. La intención se alinea con una agrupación de intenciones de expresión del usuario. Un usuario puede formular una pregunta o realizar una declaración buscando una respuesta intencionada concreta de un bot (u otra aplicación cliente). Ejemplos de intenciones pueden ser la reserva de un vuelo, preguntar sobre el tiempo en una ciudad de destino o pedir la información de contacto del servicio de atención al cliente.

Cree un elemento ModelCreateObject con el nombre de la intención única y, a continuación, pase el identificador de la aplicación, el identificador de la versión y la instancia de ModelCreateObject al método Model.AddIntentAsync. La respuesta es el identificador de la intención.

El valor intentName está codificado de forma rígida en OrderPizzaIntent como parte de las variables de la sección intentName.

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

Creación de entidades para la aplicación

Si bien las entidades no son necesarias, se encuentran en la mayoría de las aplicaciones. La entidad extrae información de la expresión del usuario, necesaria para cumplir la intención del usuario. Hay varios tipos de entidades precompiladas y personalizadas, cada una con sus propios modelos de objeto de transformación de datos. Las entidades precompiladas comunes que se pueden agregar a una aplicación incluyen number, datetimeV2, geographyV2 y ordinal.

Es importante saber que las entidades no se marcan con una intención. Pueden aplicarse, y así suelen hacerlo, a muchas intenciones. Las expresiones de usuario de ejemplo son las únicas marcadas para una intención individual específica.

Los métodos de creación de entidades forman parte de la clase Model. Cada tipo de entidad tiene su propio modelo de objeto de transformación de datos, que normalmente contiene la palabra model en el espacio de nombres model.

El código de creación de entidad crea una entidad de aprendizaje automático con subentidades y características aplicadas a las subentidades de Quantity.

// 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 el método siguiente en la clase para buscar el identificador de la subentidad Quantity con el fin de asignar las características a esa subentidad.

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

Adición de expresiones de ejemplo a la intención

Con el fin de determinar la intención de una expresión y extraer las entidades, la aplicación necesita ejemplos de expresiones. Los ejemplos deben tener como objetivo una única intención específica y deben marcar todas las entidades personalizadas. No es necesario marcar las entidades precompiladas.

Para agregar expresiones de ejemplo, cree una lista de objetos ExampleLabelObject, un objeto para cada expresión de ejemplo. Cada ejemplo debe marcar todas las entidades con un diccionario de pares nombre-valor de nombre de entidad y valor de entidad. El valor de la entidad debe reflejar exactamente lo que aparece en el texto de la expresión de ejemplo.

Llame a Examples.AddAsync con el identificador de la aplicación, el identificador de la versión y el ejemplo.

// 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); 

Entrenamiento de la aplicación

Una vez creado el modelo, debe entrenarse la aplicación de LUIS para esta versión del modelo. Un modelo entrenado puede usarse en un contenedor o bien publicarse en los espacios de ensayo o del producto.

El método Train.TrainVersionAsync necesita el id. de la aplicación y el identificador de la versión.

Un modelo muy pequeño, como el que se muestra en este inicio rápido, se entrenará muy rápidamente. En el caso de las aplicaciones en el nivel de producción, el entrenamiento de la aplicación debe incluir una llamada de sondeo al método GetStatusAsync para determinar cuándo o si el entrenamiento se realizó correctamente. La respuesta es una lista de objetos ModelTrainingInfo con un estado independiente para cada objeto. Para que el entrenamiento se considere completo, todos los objetos deben ser correctos.

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;
    }
}

Publicación de la aplicación en el espacio de producción

La aplicación de LUIS se publica con el método PublishAsync. Así se publica la versión entrenada actual en el espacio especificado en el punto de conexión. La aplicación cliente usa este punto de conexión para enviar expresiones del usuario y con ellas predecir la intención y extraer entidades.

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

Autenticación del cliente del entorno de ejecución de predicción

Use un objeto ApiKeyServiceClientCredentials con la clave y úselo con el punto de conexión para crear un objeto LUISRuntimeClient.

Precaución

En este inicio rápido se usa la clave de creación como parte de las credenciales del entorno de ejecución. La clave de creación puede consultar el entorno de ejecución con algunas consultas. Para el código de los niveles de producción y almacenamiento provisional, reemplace la clave de creación por una clave del entorno de ejecución de predicción.

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

Obtención de la predicción a partir del entorno de ejecución

Agregue el siguiente código para crear la solicitud al entorno de ejecución de predicción.

La expresión de usuario forma parte del objeto PredictionRequest.

El método GetSlotPredictionAsync necesita varios parámetros como, por ejemplo, el identificador de la aplicación, el nombre del espacio y el objeto de la solicitud de predicción para completar la solicitud. Las demás opciones, como verbose, muestran todas las intenciones y el registro es opcional.

// 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));

La respuesta de la predicción es un objeto JSON que incluye la intención y las entidades que se encuentren.

{
    "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"
                        ]
                    }
                ]
            }
        }
    }
}

Ejecución de la aplicación

Ejecute la aplicación con el comando dotnet run desde el directorio de la aplicación.

dotnet run

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

• Creación de una aplicación
• Agregar una intención, una entidad de aprendizaje automático, con una expresión de ejemplo
• Entrenamiento y publicación de la aplicación
• Consulta de runtime de predicción

Documentación de referencia | Creación y Predicción NPM | Muestras

Requisitos previos

• Node.js
• Una suscripción a Azure: cree una cuenta gratuita
• Cuando tenga la suscripción a Azure, cree un recurso de creación de Language Understanding en Azure Portal para obtener la clave de creación y el punto de conexión. Espere a que se implemente y haga clic en el botón Ir al recurso.
  • Necesitará la clave y el punto de conexión del recurso que cree para conectar la aplicación a la creación de Language Understanding. En una sección posterior de este mismo inicio rápido pegará la clave y el punto de conexión en el código siguiente. Puede usar el plan de tarifa gratuito (F0) para probar el servicio.

Instalación

Creación de una aplicación de JavaScript

1. En una ventana de consola, cree un directorio para la aplicación y muévala a ese directorio.

   mkdir quickstart-sdk && cd quickstart-sdk
   

2. Inicialice el directorio como una aplicación de JavaScript, para lo que debe crear un archivo package.json.

   npm init -y
   

3. Cree un archivo denominado index.js para el código de JavaScript.

   touch index.js
   

Instalación de las bibliotecas de NPM

Dentro del directorio de la aplicación, instale las dependencias con los siguientes comandos, que se ejecutan línea a línea:

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

Su archivo package.json debe ser similar a este:

{
  "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"
  }
}

Creación de un modelo de objetos

El cliente de creación de Language Understanding (LUIS) es un objeto LUISAuthoringClient que se autentica en Azure, que contiene la clave de creación.

Ejemplos de código para la creación

Una vez creado el cliente, úselo para acceder a la funcionalidad, entre la que se incluye:

• Aplicaciones: agregar, eliminar, publicar
• Expresiones de ejemplo: adición por lote, eliminación por identificador
• Características: administración de listas de frases
• Modelo: administración de intenciones y entidades
• Patrón: administración de patrones
• Entrenamiento: entrenamiento de la aplicación y sondeo del estado del entrenamiento
• Versiones: administración con clonación, exportación y eliminación

Modelo de objetos de predicción

El cliente de creación de Language Understanding (LUIS) es un objeto LUISAuthoringClient que se autentica en Azure, que contiene la clave de creación.

Ejemplos de código para el entorno de ejecución de predicción

Una vez creado el cliente, úselo para acceder a la funcionalidad, entre la que se incluye:

• Predicción por ranura staging o production
• Predicción por versión

Ejemplos de código

Estos fragmentos de código muestran cómo realizar las siguientes acciones con la biblioteca cliente de Language Understanding (LUIS) para Python:

• Creación de una aplicación
• Adición de intención
• Adición de entidades
• Add example utterances (Adición de expresiones de ejemplo)
• Entrenamiento de la aplicación
• Publicación de la aplicación
• Predicción por espacio

Adición de las dependencias

Abra el archivo index.js en el editor o IDE con nombre que prefiera y agregue las siguientes dependencias.

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

Adición de código reutilizable

1. Agregue el método quickstart y su llamada. Este método contiene la mayoría del código restante. A este método se le llama al final del archivo.

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

2. Agregue el código restante en el método del inicio rápido, salvo que se especifique lo contrario.

Creación de variables para la aplicación

Cree dos conjuntos de variables: cambie el primer conjunto y el segundo déjelo como aparece en el ejemplo de código.

Importante

Recuerde quitar la clave del código cuando haya terminado y no hacerla nunca pública. En el caso de producción, use una forma segura de almacenar sus credenciales y acceder a ellas, como Azure Key Vault. Consulte el artículo Seguridad de servicios de Azure AI para más información.

1. Cree variables para almacenar la clave de creación y los nombres 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. Cree variables para almacenar los puntos de conexión, el nombre de la aplicación, su versión y el nombre de la intención.

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

Autenticar el cliente

Cree un objeto CognitiveServicesCredentials con la clave y úselo con el punto de conexión para crear un objeto LUISAuthoringClient.

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

Creación de una aplicación de LUIS

Las aplicaciones de LUIS contienen el modelo de procesamiento de lenguaje natural (NLP), que incluye intenciones, entidades y expresiones de ejemplo.

Cree el método add de un objeto AppsOperation para crear la aplicación. El nombre y la referencia cultural del idioma son propiedades necesarias.

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

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

const appId = createAppResult.body

Creación de una intención para la aplicación

El objeto principal en el modelo de una aplicación LUIS es la intención. Esta se alinea con una agrupación de intenciones de expresiones de usuario. Un usuario puede formular una pregunta o realizar una declaración buscando una respuesta intencionada concreta de un bot (u otra aplicación cliente). Ejemplos de intenciones pueden ser la reserva de un vuelo, preguntar sobre el tiempo en una ciudad de destino o pedir la información de contacto del servicio de atención al cliente.

Use el método model.add_intent con el nombre de la intención única y, después, pase el identificador de la aplicación, el identificador de la versión y el nuevo nombre de la intención.

El valor intentName está codificado de forma rígida en OrderPizzaIntent como parte de las variables de la sección intentName.

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

Creación de entidades para la aplicación

Si bien las entidades no son necesarias, se encuentran en la mayoría de las aplicaciones. La entidad extrae información de la expresión del usuario, necesaria para cumplir la intención del usuario. Hay varios tipos de entidades precompiladas y personalizadas, cada una con sus propios modelos de objeto de transformación de datos. Las entidades precompiladas comunes que se pueden agregar a una aplicación incluyen number, datetimeV2, geographyV2 y ordinal.

Es importante saber que las entidades no se marcan con una intención. Pueden aplicarse, y así suelen hacerlo, a muchas intenciones. Solo las expresiones de usuario de ejemplo se marcan para una única intención específica.

Los métodos de creación de entidades forman parte de la clase Model. Cada tipo de entidad tiene su propio modelo de objeto de transformación de datos (DTO).

El código de creación de entidad crea una entidad de aprendizaje automático con subentidades y características aplicadas a las subentidades de Quantity.

// 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 el siguiente método encima del método quickstart para buscar el identificador de la subentidad Quantity con el fin de asignar las características a esa subentidad.

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

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

}

Adición de expresiones de ejemplo a la intención

Con el fin de determinar la intención de una expresión y extraer las entidades, la aplicación necesita ejemplos de expresiones. Los ejemplos deben tener como objetivo una única intención específica y deben marcar todas las entidades personalizadas. No es necesario marcar las entidades precompiladas.

Para agregar expresiones de ejemplo, cree una lista de objetos ExampleLabelObject, un objeto para cada expresión de ejemplo. Cada ejemplo debe marcar todas las entidades con un diccionario de pares nombre-valor de nombre de entidad y valor de entidad. El valor de la entidad debe reflejar exactamente lo que aparece en el texto de la expresión de ejemplo.

Llame a examples.add con el identificador de la aplicación, el identificador de la versión y el ejemplo.

// 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 });

Entrenamiento de la aplicación

Una vez creado el modelo, debe entrenarse la aplicación de LUIS para esta versión del modelo. Un modelo entrenado puede usarse en un contenedor o bien publicarse en los espacios de ensayo o del producto.

El método train.trainVersion necesita el identificador de la aplicación y el identificador de la versión.

Un modelo muy pequeño, como el que se muestra en este inicio rápido, se entrenará muy rápidamente. En el caso de las aplicaciones en el nivel de producción, el entrenamiento de la aplicación debe incluir una llamada de sondeo al método get_status para determinar si el entrenamiento se ha realizado correctamente. La respuesta es una lista de objetos ModelTrainingInfo con un estado independiente para cada objeto. Para que el entrenamiento se considere completo, todos los objetos deben ser correctos.

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;
    }
}

Publicación de la aplicación en el espacio de producción

Publique la aplicación de LUIS con el método app.publish. Así se publica la versión entrenada actual en el espacio especificado en el punto de conexión. La aplicación cliente usa este punto de conexión para enviar expresiones del usuario y con ellas predecir la intención y extraer entidades.

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

Autenticación del cliente del entorno de ejecución de predicción

Use un objeto msRest.ApiKeyCredentials con la clave y utilícelo con su punto de conexión para crear un objeto LUIS.LUISRuntimeClient.

Precaución

En este inicio rápido se usa la clave de creación como parte de las credenciales del entorno de ejecución. La clave de creación puede consultar el entorno de ejecución con algunas consultas. Para el código de los niveles de producción y almacenamiento provisional, reemplace la clave de creación por una clave del entorno de ejecución de predicción.

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

Obtención de la predicción a partir del entorno de ejecución

Agregue el siguiente código para crear la solicitud al entorno de ejecución de predicción. La expresión del usuario forma parte del objeto predictionRequest.

El método luisRuntimeClient.prediction.getSlotPrediction necesita varios parámetros como, por ejemplo, el identificador de la aplicación, el nombre de la ranura y el objeto de la solicitud de predicción para completar la solicitud. Las demás opciones, como verbose, muestran todas las intenciones y el registro es opcional.

// 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 ));

La respuesta de la predicción es un objeto JSON que incluye la intención y las entidades que se encuentren.

{
    "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"
                        ]
                    }
                ]
            }
        }
    }
}

Ejecución de la aplicación

Ejecute la aplicación con el comando node index.js en el archivo de inicio rápido.

node index.js

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

• Creación de una aplicación
• Agregar una intención, una entidad de aprendizaje automático, con una expresión de ejemplo
• Entrenamiento y publicación de la aplicación
• Consulta de runtime de predicción

Documentación de referencia Código fuente de la biblioteca de | creación y predicción | Paquete (Pypi) | Ejemplos

Requisitos previos

• La versión actual de Python 3.x.
• Una suscripción a Azure: cree una cuenta gratuita
• Cuando tenga la suscripción a Azure, cree un recurso de creación de Language Understanding en Azure Portal para obtener la clave de creación y el punto de conexión. Espere a que se implemente y haga clic en el botón Ir al recurso.
  • Necesitará la clave y el punto de conexión del recurso que cree para conectar la aplicación a la creación de Language Understanding. En una sección posterior de este mismo inicio rápido pegará la clave y el punto de conexión en el código siguiente. Puede usar el plan de tarifa gratuito (F0) para probar el servicio.

Instalación

Creación de una nueva aplicación de Python

1. En una ventana de consola, cree un directorio para la aplicación y muévala a ese directorio.

   mkdir quickstart-sdk && cd quickstart-sdk
   

2. Cree un archivo denominado authoring_and_predict.py para el código de Python.

   touch authoring_and_predict.py
   

Instalación de la biblioteca cliente con Pip

En el directorio de la aplicación, instale la biblioteca cliente de Language Understanding (LUIS) para Python con el siguiente comando:

pip install azure-cognitiveservices-language-luis

Creación de un modelo de objetos

El cliente de creación de Language Understanding (LUIS) es un objeto LUISAuthoringClient que se autentica en Azure, que contiene la clave de creación.

Ejemplos de código para la creación

Una vez creado el cliente, úselo para acceder a la funcionalidad, entre la que se incluye:

• Aplicaciones: creación, eliminación, publicación
• Expresiones de ejemplo: adición por lote, eliminación por identificador
• Características: administración de listas de frases
• Modelo: administración de intenciones y entidades
• Patrón: administración de patrones
• Entrenamiento: entrenamiento de la aplicación y sondeo del estado del entrenamiento
• Versiones: administración con clonación, exportación y eliminación

Modelo de objetos de predicción

El cliente del entorno de ejecución de predicción de Language Understanding (LUIS) es un objeto LUISRuntimeClient que se autentica en Azure, que contiene la clave del recurso.

Ejemplos de código para el entorno de ejecución de predicción

Una vez creado el cliente, úselo para acceder a la funcionalidad, entre la que se incluye:

• Predicción por almacenamiento provisional o espacio de producción
• Predicción por versión

Ejemplos de código

Estos fragmentos de código muestran cómo realizar las siguientes acciones con la biblioteca cliente de Language Understanding (LUIS) para Python:

• Creación de una aplicación
• Adición de intención
• Adición de entidades
• Add example utterances (Adición de expresiones de ejemplo)
• Entrenamiento de la aplicación
• Publicación de la aplicación
• Predicción por espacio

Adición de las dependencias

Agregue las bibliotecas de cliente al archivo de 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

Adición de código reutilizable

1. Agregue el método quickstart y su llamada. Este método contiene la mayoría del código restante. A este método se le llama al final del archivo.

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

2. Agregue el código restante en el método del inicio rápido, salvo que se especifique lo contrario.

Creación de variables para la aplicación

Cree dos conjuntos de variables: cambie el primer conjunto y el segundo déjelo como aparece en el ejemplo de código.

Importante

Recuerde quitar la clave del código cuando haya terminado y no hacerla nunca pública. En el caso de producción, use una forma segura de almacenar sus credenciales y acceder a ellas, como Azure Key Vault. Consulte el artículo Seguridad de servicios de Azure AI para más información.

1. Cree variables para almacenar la clave de creación y los nombres 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. Cree variables para almacenar los puntos de conexión, el nombre de la aplicación, su versión y el nombre de la intención.

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

Autenticar el cliente

Cree un objeto CognitiveServicesCredentials con la clave y úselo con el punto de conexión para crear un objeto LUISAuthoringClient.

client = LUISAuthoringClient(authoringEndpoint, CognitiveServicesCredentials(authoringKey))

Creación de una aplicación de LUIS

Las aplicaciones de LUIS contienen el modelo de procesamiento de lenguaje natural (NLP), que incluye intenciones, entidades y expresiones de ejemplo.

Cree el método add de un objeto AppsOperation para crear la aplicación. El nombre y la referencia cultural del idioma son propiedades necesarias.

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

Creación de una intención para la aplicación

El objeto principal en el modelo de una aplicación LUIS es la intención. Esta se alinea con una agrupación de intenciones de expresiones de usuario. Un usuario puede formular una pregunta o realizar una declaración buscando una respuesta intencionada concreta de un bot (u otra aplicación cliente). Ejemplos de intenciones pueden ser la reserva de un vuelo, preguntar sobre el tiempo en una ciudad de destino o pedir la información de contacto del servicio de atención al cliente.

Use el método model.add_intent con el nombre de la intención única y, después, pase el identificador de la aplicación, el identificador de la versión y el nuevo nombre de la intención.

El valor intentName está codificado de forma rígida en OrderPizzaIntent como parte de las variables de la sección intentName.

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

Creación de entidades para la aplicación

Si bien las entidades no son necesarias, se encuentran en la mayoría de las aplicaciones. La entidad extrae información de la expresión del usuario, necesaria para cumplir la intención del usuario. Hay varios tipos de entidades precompiladas y personalizadas, cada una con sus propios modelos de objeto de transformación de datos. Las entidades precompiladas comunes que se pueden agregar a una aplicación incluyen number, datetimeV2, geographyV2 y ordinal.

Es importante saber que las entidades no se marcan con una intención. Pueden aplicarse, y así suelen hacerlo, a muchas intenciones. Solo las expresiones de usuario de ejemplo se marcan para una única intención específica.

Los métodos de creación de entidades forman parte de la clase ModelOperations. Cada tipo de entidad tiene su propio modelo de objeto de transformación de datos (DTO).

El código de creación de entidad crea una entidad de aprendizaje automático con subentidades y características aplicadas a las subentidades de Quantity.

# 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 el siguiente método encima del método quickstart para buscar el identificador de la subentidad Quantity con el fin de asignar las características a esa subentidad.

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

Adición de expresiones de ejemplo a la intención

Con el fin de determinar la intención de una expresión y extraer las entidades, la aplicación necesita ejemplos de expresiones. Los ejemplos deben tener como objetivo una única intención específica y deben marcar todas las entidades personalizadas. No es necesario marcar las entidades precompiladas.

Para agregar expresiones de ejemplo, cree una lista de objetos ExampleLabelObject, un objeto para cada expresión de ejemplo. Cada ejemplo debe marcar todas las entidades con un diccionario de pares nombre-valor de nombre de entidad y valor de entidad. El valor de la entidad debe reflejar exactamente lo que aparece en el texto de la expresión de ejemplo.

Llame a examples.add con el identificador de la aplicación, el identificador de la versión y el ejemplo.

# 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 })

Entrenamiento de la aplicación

Una vez creado el modelo, debe entrenarse la aplicación de LUIS para esta versión del modelo. Un modelo entrenado puede usarse en un contenedor o bien publicarse en los espacios de ensayo o del producto.

El método train.train_version necesita el identificador de la aplicación y el identificador de la versión.

Un modelo muy pequeño, como el que se muestra en este inicio rápido, se entrenará muy rápidamente. En el caso de las aplicaciones en el nivel de producción, el entrenamiento de la aplicación debe incluir una llamada de sondeo al método get_status para determinar si el entrenamiento se ha realizado correctamente. La respuesta es una lista de objetos ModelTrainingInfo con un estado independiente para cada objeto. Para que el entrenamiento se considere completo, todos los objetos deben ser correctos.

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

Publicación de la aplicación en el espacio de producción

Publique la aplicación de LUIS con el método app.publish. Así se publica la versión entrenada actual en el espacio especificado en el punto de conexión. La aplicación cliente usa este punto de conexión para enviar expresiones del usuario y con ellas predecir la intención y extraer 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)

Autenticación del cliente del entorno de ejecución de predicción

Use el objeto de credenciales con la clave y úselo con el punto de conexión para crear un objeto LUISRuntimeClientConfiguration.

Precaución

En este inicio rápido se usa la clave de creación como parte de las credenciales del entorno de ejecución. La clave de creación puede consultar el entorno de ejecución con algunas consultas. Para el código de los niveles de producción y almacenamiento provisional, reemplace la clave de creación por una clave del entorno de ejecución de predicción.

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

Obtención de la predicción a partir del entorno de ejecución

Agregue el siguiente código para crear la solicitud al entorno de ejecución de predicción.

La expresión de usuario forma parte del objeto prediction_request.

El método get_slot_prediction necesita varios parámetros como, por ejemplo, el identificador de la aplicación, el nombre de la ranura y el objeto de la solicitud de predicción para completar la solicitud. Las demás opciones, como verbose, muestran todas las intenciones y el registro es opcional. La solicitud devuelve un 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))

La respuesta de la predicción es un objeto JSON que incluye la intención y las entidades que se encuentren.

{
    "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"
                        ]
                    }
                ]
            }
        }
    }
}

Ejecución de la aplicación

Ejecute la aplicación con el comando python en el archivo de inicio rápido.

python authoring_and_predict.py

Si completa este inicio rápido, realizará tres llamadas REST en secuencia.

• En primer lugar, cargará un lote de expresiones de ejemplo, que se usará para entrenar el modelo de la aplicación de pizza, mediante la llamada add labels de la API REST Batch.
• A continuación, iniciará una sesión de entrenamiento de la aplicación de pizza mediante la llamada Train application version de REST.
• Por último, obtendrá el estado de la sesión de entrenamiento de la aplicación de pizza con la llamada Get version training status de REST.

Documentación de referencia

Requisitos previos

• Una cuenta de LUIS gratuita.

• Un editor de texto, como Visual Studio Code.

• El programa de línea de comandos cURL. El programa cURL ya está instalado en macOS, la mayoría de las distribuciones de Linux y Windows 10 compilación 1803 y versiones posteriores.

  Si necesita instalar cURL, puede descargarlo desde su página de descarga.

Creación de una aplicación de pizza

Creación de la aplicación de pizza.

1. Seleccione pizza-app-for-luis-v6.json para abrir la página de GitHub para el archivo pizza-app-for-luis.json.
2. Pulse de forma prolongada o haga clic con el botón derecho en el botón Sin formato y seleccione Guardar vínculo como para guardar el archivo pizza-app-for-luis.json en el equipo.
3. Inicie sesión en el portal de LUIS.
4. Seleccione Mis aplicaciones.
5. En la página Mis aplicaciones, seleccione + Nueva aplicación para la conversación.
6. Seleccione Importar como JSON.
7. En el cuadro de diálogo Importar nueva aplicación, seleccione el botón Elegir archivo.
8. Seleccione el archivo de pizza-app-for-luis.json que descargó y, a continuación, seleccione pizza-app-for-luis.json.
9. En el cuadro de diálogo Importar nueva aplicación en el campo Nombre, escriba un nombre para la aplicación de pizza y, a continuación, seleccione el botón Listo.

Se importará la aplicación.

Si ve un cuadro de diálogo Cómo generar una aplicación eficaz de LUIS , ciérrelo.

Entrene y publique la aplicación de pizza

Debería consultar la página Intenciones con una lista de las intenciones de la aplicación de pizza.

1. En la parte superior derecha del sitio web de LUIS, seleccione el botón Entrenar.

   

2. El entrenamiento finaliza cuando el botón Entrenar está deshabilitado.

Para recibir una predicción de LUIS en un bot de chat u otras aplicaciones de cliente, debe publicar la aplicación en el punto de conexión de predicción.

1. Seleccione Publish (Publicar) en el panel de navegación superior derecho.

   

2. Seleccione el espacio de producción y, después, Done (Listo).

   

3. Seleccione Obtener acceso a la URL del punto de conexión en la notificación para ir a la página Recursos de Azure. Solo podrá ver las direcciones URL si tiene un recurso de predicción asociado a la aplicación. La página Recursos de Azure también aparece al hacer clic en Administrar.

   

Adición de un recurso de creación a la aplicación de pizza

1. Seleccione ADMINISTRAR.
2. Seleccione Recursos de Azure.
3. Seleccione Recurso de creación.
4. Seleccione Cambiar recurso de creación.

Si tiene un recurso de creación, escriba el nombre de inquilino, nombre de suscripción y nombre de recurso de LUIS del recurso de creación.

Si no tiene un recurso de creación:

1. Seleccione Crear nuevo recurso.
2. Escriba un nombre de inquilino, nombre de recurso, nombre de suscripción y nombre de grupo de recursos de Azure.

La aplicación de pizza ya está lista para usarse.

Registro de los valores de acceso de la aplicación de pizza

Para usar la nueva aplicación de pizza, necesitará el identificador de la aplicación, la clave de creación y el punto de conexión de creación de la aplicación de pizza. Para obtener predicciones, necesitará un punto de conexión de predicción y una clave de predicción diferentes.

Para establecer estos valores:

1. En la página Intenciones, seleccione ADMINISTRAR.
2. En la página Configuración de la aplicación, registre el Id. de aplicación.
3. Seleccione Recursos de Azure.
4. Seleccione Recurso de creación.
5. En las pestañas Recurso de creación y Recursos de predicción, registre la clave principal. Este valor es la clave de creación.
6. Registre la Dirección URL del punto de conexión. Este valor es el punto de conexión de creación.

Creación de un archivo JSON para entrenar la aplicación de pizza

Para crear un archivo JSON con tres expresiones de ejemplo, guarde los siguientes datos JSON en un archivo denominado 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
      }
    ]
  }
]`

El archivo JSON de expresiones de ejemplo sigue un formato específico.

El campo text contiene el texto de la expresión de ejemplo. El campo intentName debe corresponder al nombre de una intención existente en la aplicación de LUIS. El campo entityLabels es obligatorio. Si no desea etiquetar ninguna entidad, proporcione una matriz vacía.

Si la matriz entityLabels no está vacía, startCharIndex y endCharIndex tienen que marcar la entidad a la que se hace referencia en el campo entityName. El índice es de base cero. Si el texto en la etiqueta comienza o finaliza con un espacio, se produce un error en la llamada API para agregar las expresiones.

Incorporación de expresiones de ejemplo

1. Para cargar el lote de expresiones de ejemplo, copie este comando en el 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. Reemplace los valores a partir de ***YOUR- por sus propios valores.

   Información	Propósito
   ***YOUR-AUTHORING-ENDPOINT***	El punto de conexión de la dirección URL de creación. Por ejemplo, "https://REPLACE-WITH-YOUR-RESOURCE-NAME.api.cognitive.microsoft.com/". El nombre del recurso se establece al crear el recurso.
   ***YOUR-APP-ID***	El identificador de la aplicación de LUIS.
   ***YOUR-APP-VERSION***	La versión de la aplicación de LUIS. En el caso de la aplicación pizza, el número de versión es "0.1" sin las comillas.
   ***YOUR-AUTHORING-KEY***	La clave de creación de 32 caracteres.

   Las claves y recursos asignados son visibles en el portal de LUIS, en la sección Administrar de la página Recursos de Azure. El identificador de la aplicación está disponible en la misma sección Administrar, en la página Configuración de la aplicación.

   Importante

   Recuerde quitar la clave del código cuando haya terminado y no hacerla nunca pública. En el caso de producción, use una forma segura de almacenar sus credenciales y acceder a ellas, como Azure Key Vault. Consulte el artículo Seguridad de servicios de Azure AI para más información.

3. Inicie un símbolo del sistema (Windows) o el terminal (macOS y Linux) y cambie los directorios al mismo directorio en el que guardó el archivo ExampleUtterances.JSON.

4. Copie el comando cURL del editor y péguelo en un símbolo del sistema (Windows) o en el terminal (macOS y Linux). Presione ENTRAR para ejecutar el comando.

   Aparecerá la siguiente respuesta:

   [{"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}]
   

   Este es el resultado con formato para mejorar la legibilidad:

   [
     {
       "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
     }
   ]
   

Entrenamiento del modelo de la aplicación de pizza

1. Para iniciar una sesión de entrenamiento para la aplicación de pizza, copie este comando en el 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. Al igual que hizo anteriormente, reemplace los valores a partir de ***YOUR- por sus propios valores.

3. Copie el comando cURL del editor y péguelo en un símbolo del sistema (Windows) o en el terminal (macOS y Linux). Presione ENTRAR para ejecutar el comando.

   Aparecerá la siguiente respuesta:

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

   Este es el resultado con formato para mejorar la legibilidad:

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

Obtención del estado del entrenamiento

1. Para obtener el estado de la sesión de entrenamiento, copie este comando en el 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. Al igual que hizo anteriormente, reemplace los valores a partir de ***YOUR- por sus propios valores.

3. Copie el comando cURL del editor y péguelo en un símbolo del sistema (Windows) o en el terminal (macOS y Linux). Presione ENTRAR para ejecutar el comando.

   Aparecerá la siguiente respuesta:

   [{"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}}]
   

   Este es el resultado con formato para mejorar la legibilidad:

   [
     {
       "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
       }
     }
   ]
   

Obtención de la intención desde el punto de conexión de predicción

Use cURL para consultar el punto de conexión de predicción y obtener un resultado de predicción.

Nota

Este comando usa su punto de conexión de predicción.

1. Copie este comando en el 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. Reemplace los valores a partir de ***YOUR- por sus propios valores.

   Información	Propósito
   ***YOUR-PREDICTION-ENDPOINT***	El punto de conexión de la dirección URL de predicción. Se encuentra en el portal de LUIS, en la página Recursos de Azure de la aplicación. Por ejemplo, https://westus.api.cognitive.microsoft.com/.
   ***YOUR-APP-ID***	El identificador de la aplicación. Se encuentra en el portal de LUIS, en la página Configuración de la aplicación de la aplicación.
   ***YOUR-PREDICTION-KEY***	La clave de predicción de 32 caracteres. Se encuentra en el portal de LUIS, en la página Recursos de Azure de la aplicación.

3. Copie el texto en una ventana de consola y presione Entrar para ejecutar el comando:

4. Revise la respuesta de la predicción, que se devuelve 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"]}]}}}}
   

   Respuesta JSON con formato para mejorar la legibilidad:

   {
     "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"
               ]
             }
           ]
         }
       }
     }
   }
   

Limpieza de recursos

La aplicación se puede eliminar desde el portal de LUIS y los recursos de Azure desde Azure Portal.

Si usa la API REST, elimine el archivo ExampleUtterances.JSON del sistema de archivos cuando haya completado el inicio rápido.

Solución de problemas

• Autenticación en la biblioteca cliente: los errores de autenticación indican normalmente que se han usado el punto de conexión y la clave incorrectos. Por comodidad, en este inicio rápido se usan la clave y el punto de conexión de creación del runtime de predicción, pero solo funcionarán si aún no ha usado la cuota mensual. Si no puede usarlos, debe utilizar la clave y el punto de conexión del entorno de ejecución de predicción al acceder a la biblioteca cliente del SDK del entorno de ejecución de predicción.
• Creación de entidades: si recibe un error al crear la entidad de aprendizaje automático anidada que se usa en este tutorial, asegúrese de que ha copiado el código y que no lo ha modificado para crear una entidad diferente.
• Creación de expresiones de ejemplo: si recibe un error al crear la expresión del ejemplo con etiquetas usado en este tutorial, asegúrese de que ha copiado el código y de que no lo ha modificado para crear otro ejemplo con etiquetas.
• Entrenamiento: si recibe un error de entrenamiento, normalmente significa que hay una aplicación vacía (sin intenciones con expresiones de ejemplo) o una aplicación con intenciones o entidades con un formato incorrecto.
• Errores varios: dado que el código llama a las bibliotecas cliente con objetos de texto y JSON, asegúrese de que no ha cambiado el código.

Otros errores: si recibe un error que no aparece en la lista anterior, háganoslo saber; para ello, puede enviarnos sus comentarios en la parte inferior de esta página. Incluya el lenguaje de programación y la versión de las bibliotecas cliente que ha instalado.

Pasos siguientes

• Desarrollo iterativo de aplicaciones para LUIS