Reconocimiento de intenciones y entidades con LUISRecognize intents and entities with LUIS

Nota

Este tema se aplica a la versión SDK v3.This topic applies to SDK v3 release. Puede encontrar la documentación sobre la versión más reciente de SDK v4 aquí.You can find the documentation for the latest version of the SDK v4 here.

Este artículo usa el ejemplo de un bot para tomar notas, a fin de demostrar cómo Language Understanding (LUIS) ayuda a que el bot responda correctamente a la entrada de lenguaje natural.This article uses the example of a bot for taking notes, to demonstrate how Language Understanding (LUIS) helps your bot respond appropriately to natural language input. Un bot detecta lo que un usuario desea hacer mediante la identificación de su intención.A bot detects what a user wants to do by identifying their intent. Esta intención se determina a partir de la entrada de texto, voz o grabaciones de voz.This intent is determined from spoken or textual input, or utterances. La intención asigna grabaciones de voz a acciones que realiza el bot.The intent maps utterances to actions that the bot takes. Por ejemplo, un bot de toma de notas reconoce una intención Notes.Create para invocar la funcionalidad para crear una nota.For example, a note-taking bot recognizes a Notes.Create intent to invoke the functionality for creating a note. Puede que un bot también necesite extraer entidades, que son palabras importantes de las grabaciones de voz.A bot may also need to extract entities, which are important words in utterances. En el ejemplo de un bot de toma de notas, la entidad Notes.Title identifica el título de cada nota.In the example of a note-taking bot, the Notes.Title entity identifies the title of each note.

Crear un bot de Language Understanding con Bot ServiceCreate a Language Understanding bot with Bot Service

  1. En Azure Portal, haga clic en Crear nuevo recurso en la hoja de menú y, después, en Ver todo.In the Azure portal, select Create new resource in the menu blade and click See all.

    Crear recurso

  2. En el cuadro de búsqueda, busque Bot de aplicación web.In the search box, search for Web App Bot.

    Crear recurso

  3. En la hoja Servicio de bots, proporcione la información necesaria y haga clic en Crear.In the Bot Service blade, provide the required information, and click Create. Esto crea e implementa el servicio de bots y la aplicación de LUIS en Azure.This creates and deploys the bot service and LUIS app to Azure.

    • Establezca Nombre de la aplicación en el nombre del bot.Set App name to your bot’s name. El nombre se usa como el subdominio cuando el bot se implementa en la nube (por ejemplo, mynotesbot.azurewebsites.net).The name is used as the subdomain when your bot is deployed to the cloud (for example, mynotesbot.azurewebsites.net). Este nombre también se utiliza como el nombre de la aplicación de LUIS asociada con el bot.This name is also used as the name of the LUIS app associated with your bot. Cópielo para usarlo más adelante, para encontrar la aplicación de LUIS asociada con el bot.Copy it to use later, to find the LUIS app associated with the bot.

    • Seleccione la suscripción, el grupo de recursos, el plan de App Service y la ubicación.Select the subscription, resource group, App service plan, and location.

    • Seleccione la plantilla Language Understanding (C#) en el campo Bot template (Plantilla de bot).Select the Language understanding (C#) template for the Bot template field.

      Hoja Servicio de bots

    • Active la casilla para confirmar los términos del servicio.Check the box to confirm to the terms of service.

  4. Confirme que se ha implementado el servicio de bots.Confirm that the bot service has been deployed.

    • Haga clic en Notificaciones (el icono de la campana que se encuentra en el borde superior de Azure Portal).Click Notifications (the bell icon that is located along the top edge of the Azure portal). La notificación cambiará de Implementación iniciada a Implementación correcta.The notification will change from Deployment started to Deployment succeeded.
    • Después de que la notificación cambie a Implementación correcta, haga clic en Ir al recurso en esa notificación.After the notification changes to Deployment succeeded, click Go to resource on that notification.

Probar el botTry the bot

Para confirmar que el bot se ha implementado, active las Notificaciones.Confirm that the bot has been deployed by checking the Notifications. Las notificaciones cambiarán de Implementación en curso... a Implementación correcta.The notifications will change from Deployment in progress... to Deployment succeeded. Haga clic en el botón Ir al recurso para abrir la hoja de recursos del bot.Click Go to resource button to open the bot's resources blade.

Una vez registrado el bot, haga clic en Test in Web Chat (Probar en Chat en web) para abrir el panel Chat en web.Once the bot is registered, click Test in Web Chat to open the Web Chat pane. Escriba "hello" ("hola") en el Chat en web.Type "hello" in Web Chat.

Probar el bot en Chat en web

El bot responde "You have reached Greeting.The bot responds by saying "You have reached Greeting. You said: hello" ("Se ha puesto en contacto con Saludo. Ha dicho: hola").You said: hello". Esto confirma que el bot ha recibido el mensaje y lo ha pasado a una aplicación de LUIS predeterminada que ha creado.This confirms that the bot has received your message and passed it to a default LUIS app that it created. Esta aplicación de LUIS predeterminada ha detectado una intención Saludo.This default LUIS app detected a Greeting intent.

Modificación de la aplicación de LUISModify the LUIS app

Inicie sesión en https://www.luis.ai con la misma cuenta que usa para iniciar sesión en Azure.Log in to https://www.luis.ai using the same account you use to log in to Azure. Haga clic en Mis aplicaciones.Click on My apps. En la lista de aplicaciones, busque la aplicación que comienza con el nombre especificado en Nombre de la aplicación en la hoja Servicio de bots cuando creó el servicio de bots.In the list of apps, find the app that begins with the name specified in App name in the Bot Service blade when you created the Bot Service.

La aplicación de LUIS se inicia con 4 intenciones: Cancelar: Greeting, Help y None.The LUIS app starts with 4 intents: Cancel: Greeting, Help, and None.

Los siguientes pasos agregan las intenciones Note.Create, Note.ReadAloud y Note.Delete:The following steps add the Note.Create, Note.ReadAloud, and Note.Delete intents:

  1. Haga clic en Dominios creados previamente en la parte inferior izquierda de la página.Click on Prebuit Domains in the lower left of the page. Busque el dominio Nota y haga clic en Agregar dominio.Find the Note domain and click Add domain.

  2. En este tutorial no se usan todas las intenciones incluidas en el dominio Nota creado previamente.This tutorial doesn't use all of the intents included in the Note prebuilt domain. En la página Intenciones, haga clic en cada uno de los siguientes nombres de intenciones y luego haga clic en el botón Eliminar intención.In the Intents page, click on each of the following intent names and then click the Delete Intent button.

    • Note.ShowNextNote.ShowNext
    • Note.DeleteNoteItemNote.DeleteNoteItem
    • Note.ConfirmNote.Confirm
    • Note.ClearNote.Clear
    • Note.CheckOffItemNote.CheckOffItem
    • Note.AddToNoteNote.AddToNote

    Las únicas intenciones que deben permanecer en la aplicación de LUIS son las siguientes:The only intents that should remain in the LUIS app are the following:

    • Note.ReadAloudNote.ReadAloud

    • Note.CreateNote.Create

    • Note.DeleteNote.Delete

    • NoneNone

    • AyudaHelp

    • GreetingGreeting

    • CancelarCancel

      intenciones mostradas en la aplicación de LUIS

  3. Haga clic en el botón Entrenar en la esquina superior derecha para entrenar la aplicación.Click the Train button in the upper right to train your app.

  4. Haga clic en PUBLICAR en la barra de navegación superior para abrir la página Publicar.Click PUBLISH in the top navigation bar to open the Publish page. Haga clic en el botón Publish to production slot (Publicar en el espacio de producción).Click the Publish to production slot button. Tras una publicación correcta, copie la dirección URL mostrada en la columna Punto de conexión de la página Publicar aplicación, en la fila que empieza con el nombre de recurso Starter_Key.After successful publish, copy the URL displayed in the Endpoint column the Publish App page, in the row that starts with the Resource Name Starter_Key. Guarde esta dirección URL para usarla más adelante en el código del bot.Save this URL to use later in your bot’s code. La dirección URL tiene un formato similar a este ejemplo: https://westus.api.cognitive.microsoft.com/luis/v2.0/apps/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx?subscription-key=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx&timezoneOffset=0&verbose=true&q=.The URL has a format similar to this example: https://westus.api.cognitive.microsoft.com/luis/v2.0/apps/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx?subscription-key=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx&timezoneOffset=0&verbose=true&q=

Modificar el código del botModify the bot code

Haga clic en Compilar y después en Open online code editor (Abrir el editor de código en línea).Click Build and then click Open online code editor. Abrir el editor de código en líneaOpen online code editor

En el editor de código, abra BasicLuisDialog.cs.In the code editor, open BasicLuisDialog.cs. Contiene el código siguiente para controlar las intenciones de la aplicación de LUIS.It contains the following code for handling intents from the LUIS app.

using System;
using System.Configuration;
using System.Threading.Tasks;

using Microsoft.Bot.Builder.Dialogs;
using Microsoft.Bot.Builder.Luis;
using Microsoft.Bot.Builder.Luis.Models;

namespace Microsoft.Bot.Sample.LuisBot
{
    // For more information about this template visit http://aka.ms/azurebots-csharp-luis
    [Serializable]
    public class BasicLuisDialog : LuisDialog<object>
    {
        public BasicLuisDialog() : base(new LuisService(new LuisModelAttribute(
            ConfigurationManager.AppSettings["LuisAppId"], 
            ConfigurationManager.AppSettings["LuisAPIKey"], 
            domain: ConfigurationManager.AppSettings["LuisAPIHostName"])))
        {
        }

        [LuisIntent("None")]
        public async Task NoneIntent(IDialogContext context, LuisResult result)
        {
            await this.ShowLuisResult(context, result);
        }

        // Go to https://luis.ai and create a new intent, then train/publish your luis app.
        // Finally replace "Greeting" with the name of your newly created intent in the following handler
        [LuisIntent("Greeting")]
        public async Task GreetingIntent(IDialogContext context, LuisResult result)
        {
            await this.ShowLuisResult(context, result);
        }

        [LuisIntent("Cancel")]
        public async Task CancelIntent(IDialogContext context, LuisResult result)
        {
            await this.ShowLuisResult(context, result);
        }

        [LuisIntent("Help")]
        public async Task HelpIntent(IDialogContext context, LuisResult result)
        {
            await this.ShowLuisResult(context, result);
        }

        private async Task ShowLuisResult(IDialogContext context, LuisResult result) 
        {
            await context.PostAsync($"You have reached {result.Intents[0].Intent}. You said: {result.Query}");
            context.Wait(MessageReceived);
        }
    }
}

Creación de una clase para almacenar notasCreate a class for storing notes

Agregue la siguiente instrucción using en BasicLuisDialog.cs.Add the following using statement in BasicLuisDialog.cs.

using System.Collections.Generic;

Agregue el siguiente código en la clase BasicLuisDialog, después de la definición del constructor.Add the following code within the BasicLuisDialog class, after the constructor definition.

        // Store notes in a dictionary that uses the title as a key
        private readonly Dictionary<string, Note> noteByTitle = new Dictionary<string, Note>();
        
        [Serializable]
        public sealed class Note : IEquatable<Note>
        {

            public string Title { get; set; }
            public string Text { get; set; }

            public override string ToString()
            {
                return $"[{this.Title} : {this.Text}]";
            }

            public bool Equals(Note other)
            {
                return other != null
                    && this.Text == other.Text
                    && this.Title == other.Title;
            }

            public override bool Equals(object other)
            {
                return Equals(other as Note);
            }

            public override int GetHashCode()
            {
                return this.Title.GetHashCode();
            }
        }

        // CONSTANTS        
        // Name of note title entity
        public const string Entity_Note_Title = "Note.Title";
        // Default note title
        public const string DefaultNoteTitle = "default";

Control de la intención Note.CreateHandle the Note.Create intent

Para controlar la intención Note.Create, agregue el código siguiente a la clase BasicLuisDialog.To handle the Note.Create intent, add the following code to the BasicLuisDialog class.

        private Note noteToCreate;
        private string currentTitle;
        [LuisIntent("Note.Create")]
        public Task NoteCreateIntent(IDialogContext context, LuisResult result)
        {
            EntityRecommendation title;
            if (!result.TryFindEntity(Entity_Note_Title, out title))
            {
                // Prompt the user for a note title
                PromptDialog.Text(context, After_TitlePrompt, "What is the title of the note you want to create?");
            }
            else
            {
                var note = new Note() { Title = title.Entity };
                noteToCreate = this.noteByTitle[note.Title] = note;

                // Prompt the user for what they want to say in the note           
                PromptDialog.Text(context, After_TextPrompt, "What do you want to say in your note?");
            }
            
            return Task.CompletedTask;
        }
        
        
        private async Task After_TitlePrompt(IDialogContext context, IAwaitable<string> result)
        {
            EntityRecommendation title;
            // Set the title (used for creation, deletion, and reading)
            currentTitle = await result;
            if (currentTitle != null)
            {
                title = new EntityRecommendation(type: Entity_Note_Title) { Entity = currentTitle };
            }
            else
            {
                // Use the default note title
                title = new EntityRecommendation(type: Entity_Note_Title) { Entity = DefaultNoteTitle };
            }

            // Create a new note object 
            var note = new Note() { Title = title.Entity };
            // Add the new note to the list of notes and also save it in order to add text to it later
            noteToCreate = this.noteByTitle[note.Title] = note;

            // Prompt the user for what they want to say in the note           
            PromptDialog.Text(context, After_TextPrompt, "What do you want to say in your note?");

        }

        private async Task After_TextPrompt(IDialogContext context, IAwaitable<string> result)
        {
            // Set the text of the note
            noteToCreate.Text = await result;
            
            await context.PostAsync($"Created note **{this.noteToCreate.Title}** that says \"{this.noteToCreate.Text}\".");
            
            context.Wait(MessageReceived);
        }

Control de la intención Note.ReadAloudHandle the Note.ReadAloud Intent

El bot puede usar la intención Note.ReadAloud para mostrar el contenido de una nota o de todas las notas, si no se encuentra el título de la nota.The bot can use the Note.ReadAloud intent to show the contents of a note, or of all the notes if the note title isn't detected.

Pegue el código siguiente en la clase BasicLuisDialog.Paste the following code into the BasicLuisDialog class.

        [LuisIntent("Note.ReadAloud")]
        public async Task NoteReadAloudIntent(IDialogContext context, LuisResult result)
        {
            Note note;
            if (TryFindNote(result, out note))
            {
                await context.PostAsync($"**{note.Title}**: {note.Text}.");
            }
            else
            {
                // Print out all the notes if no specific note name was detected
                string NoteList = "Here's the list of all notes: \n\n";
                foreach (KeyValuePair<string, Note> entry in noteByTitle)
                {
                    Note noteInList = entry.Value;
                    NoteList += $"**{noteInList.Title}**: {noteInList.Text}.\n\n";
                }
                await context.PostAsync(NoteList);
            }

            context.Wait(MessageReceived);
        }
        
        public bool TryFindNote(string noteTitle, out Note note)
        {
            bool foundNote = this.noteByTitle.TryGetValue(noteTitle, out note); // TryGetValue returns false if no match is found.
            return foundNote;
        }
        
        public bool TryFindNote(LuisResult result, out Note note)
        {
            note = null;

            string titleToFind;

            EntityRecommendation title;
            if (result.TryFindEntity(Entity_Note_Title, out title))
            {
                titleToFind = title.Entity;
            }
            else
            {
                titleToFind = DefaultNoteTitle;
            }

            return this.noteByTitle.TryGetValue(titleToFind, out note); // TryGetValue returns false if no match is found.
        }

Control de la intención Note.DeleteHandle the Note.Delete intent

Pegue el código siguiente en la clase BasicLuisDialog.Paste the following code into the BasicLuisDialog class.

        [LuisIntent("Note.Delete")]
        public async Task NoteDeleteIntent(IDialogContext context, LuisResult result)
        {
            Note note;
            if (TryFindNote(result, out note))
            {
                this.noteByTitle.Remove(note.Title);
                await context.PostAsync($"Note {note.Title} deleted");
            }
            else
            {                             
                // Prompt the user for a note title
                PromptDialog.Text(context, After_DeleteTitlePrompt, "What is the title of the note you want to delete?");                         
            }           
        }

        private async Task After_DeleteTitlePrompt(IDialogContext context, IAwaitable<string> result)
        {
            Note note;
            string titleToDelete = await result;
            bool foundNote = this.noteByTitle.TryGetValue(titleToDelete, out note);

            if (foundNote)
            {
                this.noteByTitle.Remove(note.Title);
                await context.PostAsync($"Note {note.Title} deleted");
            }
            else
            {
                await context.PostAsync($"Did not find note named {titleToDelete}.");
            }

            context.Wait(MessageReceived);
        }

Compilar el botBuild the bot

Haga clic con el botón derecho en build.cmd en el editor de código y elija Ejecutar desde la consola.Right-click on build.cmd in the code editor and choose Run from Console.

Ejecutar build.cmd

Probar el botTest the bot

En Azure Portal, haga clic en Test in Web Chat (Probar en Chat en web) para probar el bot.In the Azure Portal, click on Test in Web Chat to test the bot. Intente escribir mensajes como "Crear una nota", "Leer mis notas" y "Eliminar notas".Try type messages like "Create a note", "read my notes", and "delete notes". Probar el bot de notas en Chat en webTest notes bot in Web Chat

Sugerencia

Si ve que el bot no reconoce siempre la intención o las entidades correctas, proporcione a la aplicación de LUIS más ejemplos de expresiones para entrenarla y mejorar su rendimiento.If you find that your bot doesn't always recognize the correct intent or entities, improve your LUIS app's performance by giving it more example utterances to train it. Puede volver a entrenar la aplicación de LUIS sin modificar el código del bot.You can retrain your LUIS app without any modification to your bot's code. Vea Add example utterances (Agregar expresiones de ejemplo) y Train and test your LUIS app (Entrenar y probar la aplicación de LUIS).See Add example utterances and train and test your LUIS app.

Sugerencia

Si se ejecuta el código del bot en un problema, compruebe lo siguiente:If your bot code runs into an issue, check the following:

  • Ha compilado el bot.You have built the bot.
  • El código del bot define un controlador para cada intención en la aplicación de LUIS.Your bot code defines a handler for every intent in your LUIS app.

Pasos siguientesNext steps

Al probar el bot, puede observar como una intención de LUIS invoca las tareas.From trying the bot, you can see how tasks are invoked by a LUIS intent. Sin embargo, este sencillo ejemplo no permite interrumpir el diálogo activo actualmente.However, this simple example doesn't allow for interruption of the currently active dialog. Permitir y controlar interrupciones como "ayuda" o "cancelar" es un diseño flexible que representa lo que el usuario hace realmente.Allowing and handling interruptions like "help" or "cancel" is a flexible design that accounts for what users really do. Obtenga más información sobre el uso de diálogos puntuables, para que los diálogos puedan controlar las interrupciones.Learn more about using scorable dialogs so that your dialogs can handle interruptions.

Recursos adicionalesAdditional resources