Utiliser Dispatch (déprécié) pour la résolution d’intentionUse Dispatch (deprecated) for intent resolution

s’applique à : SDK v4APPLIES TO: SDK v4

Si un bot utilise plusieurs modèles LUIS et QnA Maker bases de connaissances (bases de connaissances), vous pouvez utiliser l’outil de distribution pour déterminer le modèle LUIS ou la base de connaissances QnA Maker qui correspond le mieux à l’entrée utilisateur.If a bot uses multiple LUIS models and QnA Maker knowledge bases (knowledge bases), you can use the Dispatch tool to determine which LUIS model or QnA Maker knowledge base best matches the user input. L’outil Dispatch peut le déterminer en créant une application LUIS unique pour router l’entrée utilisateur vers le modèle correct.The dispatch tool does this by creating a single LUIS app to route user input to the correct model. Pour plus d’informations sur la distribution, y compris les commandes CLI, reportez-vous au fichier Lisez-moi Dispatch.For more information about Dispatch, including the CLI commands, refer to the Dispatch README.

Important

La distribution se trouve sur le chemin d’accès à déprécier et à remplacer par Orchestrator.Dispatch is on the path to be deprecated and replaced with Orchestrator. Reportez-vous à cette documentation pour plus d’informations sur la migration de votre bot pour utiliser Orchestrator.Please refer to this documentation for more information on migrating your bot to use Orchestrator.

PrérequisPrerequisites

À propos de cet exempleAbout this sample

Cet exemple est basé sur un ensemble prédéfini d’applications LUIS et QnA Maker.This sample is based on a predefined set of LUIS and QnA Maker apps.

Exemple de code-CS Flow Logic

OnMessageActivityAsync est appelé pour chaque entrée d’utilisateur reçue.OnMessageActivityAsync is called for each user input received. Ce module recherche l’intention utilisateur du scoring le plus élevé et passe ce résultat à DispatchToTopIntentAsync.This module finds the top scoring user intent and passes that result on to DispatchToTopIntentAsync. DispatchToTopIntentAsync appelle ensuite le gestionnaire d’application approprié.DispatchToTopIntentAsync, in turn, calls the appropriate app handler.

  • ProcessSampleQnAAsync : pour les questions fréquentes sur les bots.ProcessSampleQnAAsync - for bot faq questions.
  • ProcessWeatherAsync : pour les requêtes météo.ProcessWeatherAsync - for weather queries.
  • ProcessHomeAutomationAsync : pour les commandes d’éclairage domestique.ProcessHomeAutomationAsync - for home lighting commands.

Le gestionnaire appelle le service LUIS ou QnA Maker, puis retourne le résultat généré à l’utilisateur.The handler calls the LUIS or QnA Maker service and returns the generated result back to the user.

Créer des applications LUIS et une base de connaissances QnACreate LUIS apps and QnA knowledge base

Pour pouvoir créer le modèle de dispatch, vous avez besoin de créer et publier vos applications LUIS et bases de connaissances QnA.Before you can create the dispatch model, you'll need to have your LUIS apps and QnA knowledge bases created and published. Dans cet article, nous allons publier les modèles suivants inclus dans l’exemple NLP avec Dispatch dans le dossier \CognitiveModels :In this article, we'll publish the following models that are included with the NLP With Dispatch sample in the \CognitiveModels folder:

NomName DescriptionDescription
HomeAutomationHomeAutomation Application LUIS qui reconnaît une intention domotique avec les données d’entité associées.A LUIS app that recognizes a home automation intent with associated entity data.
MétéoWeather Application LUIS qui reconnaît les intentions liées à la météo avec des données de localisation.A LUIS app that recognizes weather-related intents with location data.
QnAMakerQnAMaker Base de connaissances QnA Maker qui fournit des réponses à certaines questions simples concernant le bot.A QnA Maker knowledge base that provides answers to simple questions about the bot.

Créer les applications LUISCreate the LUIS apps

  1. Créez une application LUIS à partir du fichier JSON domotique dans le répertoire des modèles cognitifs de l’exemple.Create a LUIS app from the home automation JSON file in the cognitive models directory of the sample.
    1. Former et publier l’application dans l’environnement de production.Train and publish the app to the production environment.
    2. Enregistrez l’ID d’application, le nom complet, la clé de création et l’emplacement.Record the application ID, display name, authoring key, and location.
  2. Répétez ces étapes pour le fichier JSON Weather .Repeat these steps for the weather JSON file.

Pour plus d’informations, consultez Comment créer une application Luis dans le portail Luis et obtenir des valeurs pour vous connecter à votre application Luis dans Ajouter une compréhension du langage naturel à votre bot et la documentation Luis sur la façon d’effectuer l' apprentissage et la publication d’une application dans l’environnement de production.For more information, see how to Create a LUIS app in the LUIS portal and Obtain values to connect to your LUIS app in Add natural language understanding to your bot and the LUIS documentation on how to train and publish an app to the production environment.

Créer la base de connaissances QnA MakerCreate the QnA Maker knowledge base

La première étape pour configurer une base de connaissances QnA Maker est de configurer un service QnA Maker dans Azure.The first step to setting up a QnA Maker knowledge base is to set up a QnA Maker service in Azure. Pour ce faire, suivez les instructions pas à pas de l’article configurer le service qnamaker .To do that, follow the step-by-step instructions found the set up qnamaker service article.

Une fois votre service QnA Maker créé dans Azure, vous devez enregistrer la clé Clé 1 Cognitive Services fournie pour celui-ci.Once your QnA Maker Service has been created in Azure, you need to record the Cognitive Services Key 1 provided for your QnA Maker service. Ce sera utilisé comme <azure-qna-service-key1> lors de l’ajout de l’application QnA Maker à votre application de dispatch.This will be used as <azure-qna-service-key1> when adding the QnA Maker app to your dispatch application.

Découvrez plus en détail les deux différents types de clés utilisés avec QnA Maker.Learn more about the two different types of keys used with QnA Maker.

Les étapes suivantes vous fournissent cette clé :The following steps provide you with this key:

Sélectionner Cognitive Services

  1. À partir du portail Azure, sélectionnez votre service cognitif QnA Maker.From within your Azure portal, select your QnA Maker cognitive service.

    Sélectionner des clés Cognitive Services

  2. Sélectionnez l’icône de clés qui figure sous la section Gestion des ressources dans le menu de gauche.Select the Keys icon found under the Resource Management section on the left-hand menu.

    Sélectionner la clé Clé 1 Cognitive Services

  3. Copiez la valeur de Clé 1 dans le Presse-papiers et enregistrez-la en local.Copy the value of Key 1 to your clipboard and save this locally. cela sera utilisé ultérieurement pour la valeur de clé (-k) <azure-qna-service-key1> lors de l’ajout de l’application QnA Maker à votre application de dispatch.this will later be used for the (-k) key value <azure-qna-service-key1> when adding the QnA Maker app to your dispatch application.

  4. Connectez-vous maintenant au portail web de QnAMaker.Now sign in to the QnAMaker web portal.

  5. À l’étape 2, sélectionnez les éléments suivants :At step 2, select the following:

    • Votre compte Azure AD.Your Azure AD account.
    • Le nom de votre abonnement Azure.Your Azure subscription name.
    • Le nom que vous avez créé pour votre service QnA Maker.The name you created for your QnA Maker service. (Si votre service Azure QnA n’apparaît pas dans cette liste déroulante, essayez d’actualiser la page.)(If your Azure QnA service does not initially appear in this pull down list, try refreshing the page.)

    Créer QnA - Étape 2

  6. À l’étape 3, fournissez un nom pour votre base de connaissances QnA Maker.At step 3, provide a name for your QnA Maker knowledge base. Pour cet exemple, utilisez le nom sample-qna.For this example use the name 'sample-qna'.

    Créer QnA - Étape 3

  7. À l’étape 4, sélectionnez l’option + Ajouter un fichier, accédez au dossier CognitiveModel de votre exemple de code et sélectionnez le fichier « QnAMaker.tsv ».At step 4, select the option + Add File, navigate to the CognitiveModel folder of your sample code, and select the file 'QnAMaker.tsv'. Il existe une sélection supplémentaire pour ajouter une personnalité Chit-chat à votre base de connaissances, mais notre exemple n’inclut pas cette option.There is an additional selection to add a Chit-chat personality to your knowledge base but our example does not include this option.

    Créer QnA - Étape 4

  8. À l’étape 5, créez votre base de connaissances.At step 5, select Create your knowledge base.

  9. Une fois qu’une base de connaissances a été créée à partir de votre fichier chargé, sélectionnez Save and train (Enregistrer et entraîner) et quand vous avez terminé, sélectionnez l’onglet PUBLISH et publiez votre application.Once the knowledge base is created from your uploaded file, select Save and train and when finished, select the PUBLISH Tab and publish your app.

  10. Une fois que votre application QnA Maker est publiée, sélectionnez l’onglet SETTINGS et faites défiler jusqu’à « Deployment details ».Once your QnA Maker app is published, select the SETTINGS Tab, and scroll down to 'Deployment details'. Enregistrez les valeurs suivantes à partir de la requête HTTP de l’exemple Postman.Record the following values from the Postman Sample HTTP request.

    POST /knowledge bases/<knowledge-base-id>/generateAnswer
    Host: <your-hostname>  // NOTE - this is a URL.
    Authorization: EndpointKey <qna-maker-resource-key>
    

    La chaîne d’URL complète du nom d’hôte doit ressembler à « https://.azure.net/qnamaker ».The full URL string for your hostname will look like "https://.azure.net/qnamaker". Ces valeurs seront utilisées ultérieurement dans votre fichier appsettings.json ou .env.These values will later be used within your appsettings.json or .env file.

L’application de dispatch a besoin d’un accès en lecture aux applications existantesDispatch app needs read access to existing apps

L’outil de dispatch a besoin d’un accès en création pour lire les applications LUIS et QnA Maker existantes afin de créer une nouvelle application parente LUIS qui effectue le dispatch aux applications LUIS et QnA Maker.The dispatch tool needs authoring access to read the existing LUIS and QnA Maker apps in order to create a new parent LUIS app that dispatches to the LUIS and QnA Maker apps. Cet accès est fourni avec les ID d’application et les clés de création.This access is provided with the app IDs and authoring keys.

Clés de création de serviceService authoring keys

La clé de création est utilisée uniquement pour la création et la modification des modèles.The authoring key is only used for creating and editing the models. Vous avez besoin d’un ID et d’une clé pour chacune des applications LUIS et QnA Maker.You need an ID and key for each of the two LUIS apps and the QnA Maker app.

  • pour LUISfor LUIS
    • L' ID d’application se trouve dans le portail Luis pour chaque application, gérer les paramètres de > > paramètres de l’applicationThe App ID is found in the LUIS portal for each app, Manage > Settings > Application Settings
    • La clé de création se trouve dans le portail Luis, dans l’angle supérieur droit, sélectionnez votre propre utilisateur, puis paramètres.The Authoring Key is found in the LUIS portal, top-right corner, select your own User, then Settings.
  • pour QnA Makerfor Qna Maker
    • L' ID d’application se trouve dans le portail QnA Maker sur la page paramètres après la publication de l’application.The App ID is found in the QnA Maker portal on the Settings page after you publish the app. Il s’agit de l’ID figurant dans la première partie de la commande POST après la base de connaissances.This is the ID found in first part of the POST command after the knowledgebase. POST /knowledgebases/<APP-ID>/generateAnswer est un exemple d’emplacement où trouver l’ID d’application.An example of where to find the app ID is POST /knowledgebases/<APP-ID>/generateAnswer.
    • La clé de création se trouve dans le portail Azure, pour la ressource QnA Maker, sous les clés.The Authoring Key is found in the Azure portal, for the QnA Maker resource, under the Keys. Vous avez seulement besoin d’une des clés.You only need one of the keys.

La clé de création n’est pas utilisée pour obtenir un score de prédiction ni un score de confiance de l’application publiée.The authoring key is not used to get a prediction score or confidence score from the published application. Vous avez besoin des clés de point de terminaison pour cette action.You need the endpoint keys for this action. Les clés de point de terminaison sont disponibles et utilisées ultérieurement dans ce tutoriel.The endpoint keys are found and used later in this tutorial.

Découvrez plus en détail les deux différents types de clés utilisés avec QnA Maker.Learn more about the two different types of keys used with QnA Maker.

Créer le modèle de dispatchCreate the dispatch model

L’interface CLI de l’outil Dispatch crée le modèle de dispatch à l’application LUIS ou QnA Maker appropriée.The CLI interface for the dispatch tool creates the model for dispatching to the correct LUIS or QnA Maker app.

  1. Ouvrez une invite de commandes ou une fenêtre de terminal, puis remplacez les répertoires par le répertoire CognitiveModels.Open a command prompt or terminal window, and change directories to the CognitiveModels directory

  2. Vérifiez que la version actuelle de npm et l’outil Dispatch sont installés.Make sure you have the current version of npm and the Dispatch tool.

    npm i -g npm
    npm i -g botdispatch
    
  3. Utilisez dispatch init pour initialiser la création d’un fichier .dispatch pour votre modèle de dispatch.Use dispatch init to initialize create a .dispatch file for your dispatch model. Créez-le en utilisant un nom de fichier facile à reconnaître.Create this using a filename you will recognize.

    dispatch init -n <filename-to-create> --luisAuthoringKey "<your-luis-authoring-key>" --luisAuthoringRegion <your-region>
    
  4. Utilisez dispatch add pour ajouter vos applications LUIS et bases de connaissances QnA Maker au fichier .dispatch.Use dispatch add to add your LUIS apps and QnA Maker knowledge bases to the .dispatch file.

    dispatch add -t luis -i "<app-id-for-weather-app>" -n "<name-of-weather-app>" -v <app-version-number> -k "<your-luis-authoring-key>" --intentName l_Weather
    dispatch add -t luis -i "<app-id-for-home-automation-app>" -n "<name-of-home-automation-app>" -v <app-version-number> -k "<your-luis-authoring-key>" --intentName l_HomeAutomation
    dispatch add -t qna -i "<knowledge-base-id>" -n "<knowledge-base-name>" -k "<azure-qna-service-key1>" --intentName q_sample-qna
    
  5. Utilisez dispatch create pour générer un modèle de dispatch à partir du fichier .dispatch.Use dispatch create to generate a dispatch model from the .dispatch file.

    dispatch create
    
  6. Publiez l’application de dispatch LUIS que vous venez de créer.Publish the dispatch LUIS app, just created.

Utiliser l’application de dispatch LUISUse the dispatch LUIS app

L’application LUIS générée définit les intentions de chacune des applications enfants et des bases de connaissances, ainsi qu’une intention aucune pour les cas où l’énoncé ne correspond à rien.The generated LUIS app defines intents for each of the child apps and the knowledge base, as well as a none intent for when the utterance doesn't have a good fit.

  • l_HomeAutomation
  • l_Weather
  • None
  • q_sample-qna

Ces services ont besoin d’être publiés sous les noms corrects pour que le bot s’exécute correctement.These services need to be published under the correct names for the bot to run properly. Le bot a besoin d’informations sur les services publiés pour pouvoir accéder à ces services.The bot needs information about the published services, so that it can access those services.

Clés de point de terminaison de serviceService endpoint keys

Le bot a besoin de points de terminaison de prédiction de requête pour les trois applications LUIS (dispatch, météo et domotique) et la base de connaissances QnA Maker unique.The bot needs the query prediction endpoints for the three LUIS apps (dispatch, weather, and home automation) and the single QnA Maker knowledge base. Recherchez les clés de point de terminaison dans les portails LUIS et QnA Maker :Find the endpoint keys in the LUIS and QnA Maker portals:

  • Dans le portail LUIS, pour chaque application LUIS, dans la section Manager (Gérer), sélectionnez Paramètres des clés et points de terminaison pour trouver les clés associées à chaque application.In the LUIS portal, for each LUIS app, in the Manage section, select Keys and Endpoint settings to find the keys associated with each app. Si vous suivez ce tutoriel, la clé de point de terminaison est la même clé que <your-luis-authoring-key>.If you are following this tutorial, the endpoint key is the same key as the <your-luis-authoring-key>. La clé de création est valide pour 1 000 points de terminaison, puis elle expire.The authoring key allows for 1000 endpoint hits then expires.
  • Dans le portail QnA Maker, pour la base de connaissances, dans les paramètres Gérer, utilisez la valeur de clé qui s’affiche dans les paramètres Postman pour l’en-tête Authorization, sans le texte de EndpointKey.In the QnA Maker portal, for the knowledge base, in the Manage settings, use the key value shows in the Postman settings for the Authorization header, without the text of EndpointKey.

Ces valeurs sont utilisées dans le fichier de configuration de l’exemple : appsettings.jssur (C#), . env (JavaScript) ou config.py (Python).These values are used in the sample's configuration file: appsettings.json (C#), .env (JavaScript), or config.py (Python).

Installation des packagesInstalling packages

Avant d’exécuter cette application pour la première fois, vérifiez que plusieurs packages NuGet sont installés :Prior to running this app for the first time ensure that several NuGet packages are installed:

  • Microsoft.Bot.BuilderMicrosoft.Bot.Builder
  • Microsoft.Bot.Builder.AI.LuisMicrosoft.Bot.Builder.AI.Luis
  • Microsoft.Bot.Builder.AI.QnAMicrosoft.Bot.Builder.AI.QnA

Mettre à jour manuellement votre fichier appsettings.jsonManually update your appsettings.json file

Une fois que toutes vos applications de service sont créées, les informations de chacune d’elles doivent être ajoutées dans votre fichier « appsettings.json ».Once all of your service apps are created, the information for each needs to be added into your 'appsettings.json' file. Le code de l’exemple C# initial contient un fichier appsettings.json vide :The initial C# Sample code contains an empty appsettings.json file:

appsettings.jsonappsettings.json


"LuisHomeAutomationAppId": "",
"LuisWeatherAppId": "",
"LuisAPIKey": "",
"LuisAPIHostName": "",

"AllowedHosts": "*",

"Orchestrator": {
  "ModelFolder": ".\\model",

Pour chacune des entités indiquées ci-dessous, ajoutez les valeurs que vous avez enregistrées précédemment dans ces instructions :For each of the entities shown below, add the values you recorded earlier in these instructions:

appsettings.jsonappsettings.json

"MicrosoftAppId": "",
"MicrosoftAppPassword": "",

"QnAKnowledgebaseId": "<knowledge-base-id>",
"QnAEndpointKey": "<qna-maker-resource-key>",
"QnAEndpointHostName": "<your-hostname>",

"LuisAppId": "<app-id-for-dispatch-app>",
"LuisAPIKey": "<your-luis-endpoint-key>",
"LuisAPIHostName": "<your-dispatch-app-region>",

Quand tous les changements sont en place, enregistrez ce fichier.When all changes are complete, save this file.

Vous connecter aux services à partir de votre botConnect to the services from your bot

Pour vous connecter aux services Dispatch, LUIS et QnA Maker, votre bot extrait les informations du fichier de paramètres.To connect to the Dispatch, LUIS, and QnA Maker services, your bot pulls information from the settings file.

Dans BotServices.cs, les informations contenues dans le fichier de configuration appsettings.json permettent de connecter votre bot de dispatch aux services Dispatch et SampleQnA.In BotServices.cs, the information contained within configuration file appsettings.json is used to connect your dispatch bot to the Dispatch and SampleQnA services. Les constructeurs utilisent les valeurs que vous avez fournies pour se connecter à ces services.The constructors use the values you provided to connect to these services.

BotServices.csBotServices.cs

{
    public class BotServices : IBotServices
    {
        public BotServices(IConfiguration configuration, OrchestratorRecognizer dispatcher)
        {
            // Read the setting for cognitive services (LUIS, QnA) from the appsettings.json
            // If includeApiResults is set to true, the full response from the LUIS api (LuisResult)
            // will be made available in the properties collection of the RecognizerResult
            LuisHomeAutomationRecognizer = CreateLuisRecognizer(configuration, "LuisHomeAutomationAppId");
            LuisWeatherRecognizer = CreateLuisRecognizer(configuration, "LuisWeatherAppId");

            Dispatch = dispatcher;

            SampleQnA = new QnAMaker(new QnAMakerEndpoint
            {
                KnowledgeBaseId = configuration["QnAKnowledgebaseId"],
                EndpointKey = configuration["QnAEndpointKey"],
                Host = configuration["QnAEndpointHostName"]
            });
        }

        public OrchestratorRecognizer Dispatch { get; private set; }
        
        public QnAMaker SampleQnA { get; private set; }
        
        public LuisRecognizer LuisHomeAutomationRecognizer { get; private set; }

        public LuisRecognizer LuisWeatherRecognizer { get; private set; }

        private LuisRecognizer CreateLuisRecognizer(IConfiguration configuration, string appIdKey)
        {
            var luisApplication = new LuisApplication(
                configuration[appIdKey],
                configuration["LuisAPIKey"],
                configuration["LuisAPIHostName"]);

            // Set the recognizer options depending on which endpoint version you want to use.
            // More details can be found in https://docs.microsoft.com/en-gb/azure/cognitive-services/luis/luis-migration-api-v3

Notes

Par défaut, le paramètre includeApiResults a la valeur false, ce qui signifie que le module de reconnaissance retourne uniquement des informations de base sur les entités/intentions.By default the includeApiResults parameter is set to false, meaning the recognizer will only return basic information about entities / intents. Si vous avez besoin de la réponse complète de LUIS (comme le ConnectedServiceResult utilisé plus loin dans ce tutoriel), affectez la valeur true à ce paramètre.If you require the full response from LUIS (such as the ConnectedServiceResult used later in this tutorial), then set this parameter to true. Cette opération ajoutera alors la réponse complète du service LUIS à la collection Properties de RecognizerResult.This will then add the full response from the LUIS service into the Properties collection on the RecognizerResult.

Appeler les services à partir de votre botCall the services from your bot

Pour chaque entrée utilisateur, la logique du bot effectue une vérification par rapport au modèle Dispatch combiné, trouve l’intention retournée en premier et utilise ces informations pour appeler le service approprié à l’entrée.For each input from your user, the bot logic checks user input against the combined Dispatch model, finds the top returned intent, and uses that information to call the appropriate service for the input.

Dans le fichier DispatchBot.cs, chaque fois que la méthode OnMessageActivityAsync est appelée, nous vérifions le message utilisateur entrant par rapport au modèle Dispatch.In the DispatchBot.cs file whenever the OnMessageActivityAsync method is called, we check the incoming user message against the Dispatch model. Nous passons ensuite les éléments topIntent et recognizerResult du modèle Dispatch à la méthode appropriée pour appeler le service et retourner le résultat.We then pass the Dispatch Model's topIntent and recognizerResult on to the correct method to call the service and return the result.

bots\DispatchBot.csbots\DispatchBot.cs


protected override async Task OnMessageActivityAsync(ITurnContext<IMessageActivity> turnContext, CancellationToken cancellationToken)
{
    var dc = new DialogContext(new DialogSet(), turnContext, new DialogState());
    // Top intent tell us which cognitive service to use.
    var allScores = await _botServices.Dispatch.RecognizeAsync(dc, (Activity)turnContext.Activity, cancellationToken);
    var topIntent = allScores.Intents.First().Key;
    
    // Next, we call the dispatcher with the top intent.
    await DispatchToTopIntentAsync(turnContext, topIntent, cancellationToken);
}

Utiliser les résultats de reconnaissanceWork with the recognition results

Lorsque le modèle renvoie un résultat, il indique quel service est le mieux à même de gérer l’énoncé.When the model produces a result, it indicates which service can most appropriately process the utterance. Le code de ce bot achemine la demande vers le service correspondant, puis il résume la réponse du service appelé.The code in this bot routes the request to the corresponding service, and then summarizes the response from the called service. Selon l’intention retournée par Dispatch, ce code utilise l’intention retournée pour router vers le modèle LUIS ou service QnA approprié.Depending on the intent returned from Dispatch, this code uses the returned intent to route to the correct LUIS model or QnA service.

bots\DispatchBot.csbots\DispatchBot.cs

private async Task DispatchToTopIntentAsync(ITurnContext<IMessageActivity> turnContext, string intent, CancellationToken cancellationToken)
{
    switch (intent)
    {
        case "HomeAutomation":
            await ProcessHomeAutomationAsync(turnContext, cancellationToken);
            break;
        case "Weather":
            await ProcessWeatherAsync(turnContext, cancellationToken);
            break;
        case "QnAMaker":
            await ProcessSampleQnAAsync(turnContext, cancellationToken);
            break;
        default:
            _logger.LogInformation($"Dispatch unrecognized intent: {intent}.");
            await turnContext.SendActivityAsync(MessageFactory.Text($"Dispatch unrecognized intent: {intent}."), cancellationToken);
            break;
    }
}

Si la méthode ProcessHomeAutomationAsync ou ProcessWeatherAsync est appelée, les résultats lui sont passés à partir du modèle de dispatch au sein de luisResult.ConnectedServiceResult.If method ProcessHomeAutomationAsync or ProcessWeatherAsync are invoked, they are passed the results from the dispatch model within luisResult.ConnectedServiceResult. La méthode spécifiée fournit alors des commentaires utilisateur indiquant la première intention du modèle de dispatch, ainsi que la liste ordonnée de tous les intentions et entités détectées.The specified method then provides user feedback showing the dispatch model top intent, plus a ranked listing of all intents and entities that were detected.

Si la méthode q_sample-qna est appelée, elle utilise l’entrée utilisateur contenue dans turnContext pour générer une réponse à partir de la base de connaissances et présenter ce résultat à l’utilisateur.If method q_sample-qna is invoked, it uses the user input contained within the turnContext to generate an answer from the knowledge base and display that result to the user.

Notes

S’il s’agissait d’une application de production, c’est là que les méthodes LUIS sélectionnées se connecteraient à leur service spécifié, passeraient l’entrée utilisateur et traiteraient les données d’intention et d’entité LUIS retournées.If this were a production application, this is where the selected LUIS methods would connect to their specified service, pass in the user input, and process the returned LUIS intent and entity data.

Tester votre robotTest your bot

  1. À l’aide de votre environnement de développement, démarrez l’exemple de code.Using your development environment, start the sample code. Notez l’adresse localhost indiquée dans la barre d’adresses de la fenêtre de navigateur ouverte par votre application : « https://localhost:<Port_Number>  ».Note the localhost address shown in the address bar of the browser window opened by your App: "https://localhost:<Port_Number>".

  2. Ouvrez l’émulateur de l’infrastructure bot, puis sélectionnez Create a new bot configuration .Open Bot Framework Emulator, then select Create a new bot configuration. Un .bot fichier vous permet d’utiliser l' inspecteur dans l’émulateur pour voir le JSON retourné par Luis et QnA Maker.A .bot file enables you to use the Inspector in the Emulator to see the JSON returned from LUIS and QnA Maker.

  3. Dans la boîte de dialogue New bot configuration (Nouvelle configuration de bot) , entrez le nom de votre bot et votre URL de point de terminaison, telle que http://localhost:3978/api/messages.In the New bot configuration dialog box, enter your bot name, and your endpoint URL, such as http://localhost:3978/api/messages. Enregistrez le fichier à la racine de votre projet d’exemples de code de bot.Save the file at the root of your bot sample code project.

  4. Ouvrez le fichier du bot et ajoutez des sections pour vos applications LUIS et QnA Maker.Open the bot file and add sections for your LUIS and QnA Maker apps. Utilisez cet exemple de fichier en tant que modèle pour les paramètres.Use this example file as a template for settings. Enregistrez les modifications.Save the changes.

  5. Sélectionnez le nom de bot dans la liste Mes bots pour accéder à votre bot actif.Select the bot name in the My Bots list to access your running bot. À titre de référence, voici quelques-unes des questions et commandes couvertes par les services générés pour votre bot :For your reference, here are some of the questions and commands that are covered by the services built for your bot:

    • QnA MakerQnA Maker
      • hi, good morninghi, good morning
      • what are you, what do you dowhat are you, what do you do
    • LUIS (domotique)LUIS (home automation)
      • turn on bedroom light
      • turn off bedroom light
      • make some coffee
    • LUIS (météo)LUIS (weather)
      • whats the weather in redmond washington
      • what's the forecast for london
      • show me the forecast for nebraska

Dispatch pour énoncé utilisateur à QnA MakerDispatch for user utterance to QnA Maker

  1. Dans l’émulateur de bot, entrez le texte hi et envoyez l’énoncé.In the bot Emulator, enter the text hi and submit the utterance. Le bot soumet cette requête à l’application de dispatch LUIS et reçoit en retour une réponse indiquant quelle application enfant doit obtenir cet énoncé pour un traitement ultérieur.The bot submits this query to the dispatch LUIS app and gets back a response indicating which child app should get this utterance for further processing.

  2. En sélectionnant la LUIS Trace ligne dans le journal, vous pouvez voir la réponse Luis dans l’émulateur de bot.By selecting the LUIS Trace line in the log, you can see the LUIS response in the bot Emulator . Le résultat LUIS de l’application de dispatch LUIS s’affiche dans l’inspecteur.The LUIS result from the dispatch LUIS app displays in the Inspector.

    {
      "luisResponse": {
        "entities": [],
        "intents": [
          {
            "intent": "q_sample-qna",
            "score": 0.9489713
          },
          {
            "intent": "l_HomeAutomation",
            "score": 0.0612499453
          },
          {
            "intent": "None",
            "score": 0.008567564
          },
          {
            "intent": "l_Weather",
            "score": 0.0025761195
          }
        ],
        "query": "Hi",
        "topScoringIntent": {
          "intent": "q_sample-qna",
          "score": 0.9489713
        }
      }
    }
    

    Étant donné que l’énoncé hi fait partie de l’intention q_sample-qna de l’application de dispatch LUIS et qu’il est sélectionné en tant que topScoringIntent, le bot effectue une deuxième requête, cette fois à l’application QnA Maker, avec le même énoncé.Because the utterance, hi, is part of the dispatch LUIS app's q_sample-qna intent, and is selected as the topScoringIntent, the bot will make a second request, this time to the QnA Maker app, with the same utterance.

  3. Sélectionnez la QnAMaker Trace ligne dans le journal de l’émulateur de bot.Select the QnAMaker Trace line in the bot Emulator log. Le résultat QnA Maker s’affiche dans l’inspecteur.The QnA Maker result displays in the Inspector.

{
    "questions": [
        "hi",
        "greetings",
        "good morning",
        "good evening"
    ],
    "answer": "Hello!",
    "score": 1,
    "id": 96,
    "source": "QnAMaker.tsv",
    "metadata": [],
    "context": {
        "isContextOnly": false,
        "prompts": []
    }
}

Résolution d’une intention supérieure incorrecte à partir de DispatchResolving incorrect top intent from Dispatch

Une fois que votre bot est en cours d’exécution, il est possible d’améliorer les performances du bot en supprimant les énoncés similaires ou qui se recoupent entre les applications dispatchées.Once your bot is running, it is possible to improve the bot's performance by removing similar or overlapping utterances between the dispatched apps.

Vous pouvez utiliser l’outil en ligne de commande Dispatch pour tester et évaluer votre modèle de dispatch.You can use the Dispatch command-line tool to test and evaluate your dispatch model.

Mettre à jour ou créer un modèle LUISTo update or create a new LUIS model

cet exemple est basé sur un modèle LUIS préconfiguré.This sample is based on a preconfigured LUIS model. Vous trouverez des informations supplémentaires pour vous aider à mettre à jour ce modèle, ou créer un nouveau modèle LUIS, dans l’article conception d’applications itératives pour Luis.Additional information to help you update this model, or create a new LUIS model, can be found in the article Iterative app design for LUIS.

Après la mise à jour des modèles sous-jacents (QnA ou LUIS), exécutez dispatch refresh pour mettre à jour votre application Dispatch LUIS.After updating the underlying models (QnA or LUIS) run dispatch refresh to update your Dispatch LUIS app. dispatch refresh est fondamentalement la même commande que dispatch create, à ceci près qu’aucun ID d’application LUIS n’est créé.dispatch refresh is basically the same command as dispatch create except no new LUIS app ID is created.

Notez que les énoncés ajoutés directement dans LUIS ne sont pas conservés lors de l’exécution de dispatch refresh.Note that utterances that were added directly in LUIS will not be retained when running dispatch refresh. Pour conserver ces énoncés supplémentaires dans l’application Dispatch, ajoutez-les dans un fichier texte (un énoncé par ligne), puis ajoutez le fichier à Dispatch en exécutant la commande :To keep those extra utterances in the Dispatch app add those utterances in a text file (one utterance per line), and then add the file to Dispatch by running the command:

dispatch add -t file -f <file path> --intentName <target intent name, ie l_General>

À partir du moment où le fichier contenant les énoncés supplémentaires est ajouté à Dispatch, les énoncés demeurent à chaque actualisation.Once the file with extra utterances is added to Dispatch the utterances will stay with every refresh.

Pour supprimer des ressourcesTo delete resources

cet exemple crée un certain nombre d’applications et de ressources que vous pouvez supprimer à l’aide de la procédure ci-dessous. Veillez toutefois à ne pas supprimer les ressources dont dépendent d’autres applications ou services.This sample creates a number of applications and resources that you can delete using the steps listed below, but you should not delete resources that any other apps or services rely on.

Pour supprimer des ressources LUIS :To delete LUIS resources:

  1. Connectez-vous au portail luis.ai.Sign in to the luis.ai portal.
  2. Accédez à la page My Apps (Mes applications).Go to the My Apps page.
  3. Sélectionnez les applications créées par cet exemple.Select the apps created by this sample.
    • Home Automation
    • Weather
    • NLP-With-Dispatch-BotDispatch
  4. Cliquez sur Delete (Supprimer), puis sur Ok pour confirmer.Click Delete, and click Ok to confirm.

Pour supprimer des ressources QnA Maker :To delete QnA Maker resources:

  1. Connectez-vous au portail qnamaker.ai.Sign in to the qnamaker.ai portal.
  2. Accédez à la page My knowledge bases (Mes bases de connaissances).Go to the My knowledge bases page.
  3. Cliquez sur le bouton de suppression de la base de connaissances Sample QnA, puis cliquez sur Delete (Supprimer) pour confirmer.Click the delete button for the Sample QnA knowledge base, and click Delete to confirm.

Bonne pratiqueBest practice

Pour améliorer les services utilisés dans cet exemple, reportez-vous aux bonnes pratiques pour LUIS et QnA Maker.To improve services used in this sample, refer to best practice for LUIS, and QnA Maker.