Article
12/22/2016

Décembre 2016

Volume 31, numéro 13

Cet article a fait l'objet d'une traduction automatique.

Microsoft Bot Framework - Utiliser Bot Framework pour un accès à tout moment et en tout lieu aux données des applications

Dans le dernier numéro j’ai présenté l’infrastructure de robot de Microsoft et décrit comment vous pouvez tirer parti de celui-ci à relever un défi que de nombreuses organisations font face aujourd'hui, qui consiste à offrir aux clients d’accéder de façon interactive à leurs services, via les fonctionnalités vocales et de texte (msdn.com/magazine/mt788623). Dans cet article, j’ai décrit un scénario d’entreprise qui impliquait la consolidation des informations de différentes applications line-of-business déployées dans une organisation de fournisseur d’assurance, à l’aide de technologies telles que Microsoft Flow et applications logiques Azure. Indexation du contenu, comprenant les données structurées et non structurées, à l’aide d’Azure Search et mis à disposition pour les applications clientes à utiliser.

Figure 1, qui apparaît également dans l’article précédent, illustre l’architecture de la solution qui implémente le scénario.

Figure 1 Architecture de la Solution

Dans cet article, je vais créer et déployer une application de robot qui peut consommer les informations recueillies par l’intermédiaire d’Azure. L’application bot est déployée comme une application Web Azure et publiée via le Service du connecteur Microsoft Bot Framework. L’application Bot sera accessible via le Service du connecteur, le canal Skype, qui donnent accès aux consommateurs à l’état de leurs demandes d’assurance et leur permettre de télécharger les documents de stratégie émis, planifier des visites d’inspection et ainsi de suite. Consommateurs sera en mesure de s’identifier auprès du robot à l’aide du compte Microsoft qu’ils utilisent lors de l’application pour une police d’assurance, et peuvent utiliser la messagerie soit sur le client Skype ou d’interagir avec le robot commandes vocales. L’application de robot s’intègre avec le service LUIS, parmi plusieurs services disponibles dans Azure Services Cognitive, interpréter les conversations du consommateur afin d’exécuter des requêtes sur Azure Search.

Les étapes requises pour générer la solution sont expliquées dans la séquence suivante. Les extraits de code sont extraites de la solution Visual Studio 2015, qui peut être téléchargée avec cet article. Voici ce que vous devez faire si vous programmez :

Créer et publier un modèle de LUIS qui capture les conversations différents qui doivent être pris en charge dans le robot à l’aide de l’interface Utilisateur fournie par le service LUIS.
Utilisez le modèle Visual Studio 2015 pour créer une nouvelle application de robot. Vous pouvez ajouter des blocs de code à partir de la solution fournie avec cet article ou suivez le reste de l’article qui fait référence au fichier solution téléchargée. Le fichier MessageController.cs est le point d’entrée dans l’application de robots, qui est un type spécial d’une application .NET MVC.
Incorporer la fonctionnalité LUIS dans le robot à l’aide de la boîte de dialogue LUIS disponible dans le Kit de Développement Framework robot. Cela est implémenté dans le fichier PolicyInfoDialog.cs dans la solution.
À l’aide du SDK Azure Search, implémenter le code qui appelle l’API Azure Search et exécuter des requêtes de recherche interprétés par le service LUIS. Cela est implémenté dans le fichier SearchService.cs dans la solution.
Implémenter une boîte de dialogue FormFlow pour capturer le compte d’utilisateur Microsoft dans le canal Skype, de manière interactive, lorsqu’un utilisateur est demandé la première fois. Cela est implémenté dans le fichier SigninForm.cs dans la solution qui accompagne cet article.
Utilisez le SDK Azure Search pour récupérer les informations de profil utilisateur en fonction du compte Microsoft capturé lorsque l’utilisateur accède pour la première fois à l’outil. Cela est également implémentée dans SearchService.cs
Le Service d’état Bot permet de conserver les informations de profil utilisateur. Informations de l’utilisateur du robot d’adresse et contact, qui sont stockées dans le Service d’état Bot, sont utilisées lors de la planification d’une visite du site. Cela est également implémentée dans le fichier PolicyInfoDialog.cs.
Tester l’application de robot en l’exécutant localement en tant que service sur votre ordinateur de développement et utiliser l’émulateur de canal de Framework robot pour évaluer l’interaction utilisateur avec le service.
Après avoir testé l’application bot localement, déployez-le dans une application Web dans Azure à droite à partir de Visual Studio.
Enregistrez l’application de robot avec le Service du connecteur Microsoft Bot Framework et configurer qu’il contient l’URL de l’application de robot déployée sur Azure.
Ajouter le nom d’application du robot, ID d’application et des informations secrets obtenues lors de l’inscription du robot, dans la solution Visual Studio et le republier sur Azure.
Permettre à l’application de robot pour l’accès à partir de canaux tels que Skype et marge, du portail développeur robot.

Vous pouvez télécharger la solution Visual Studio 2015 pour l’application de robot et une exportation de fichier du modèle LUIS utilisée dans cette application à partir du référentiel GitHub à bit.ly/2cOfANh.

Création et l’apprentissage du modèle LUIS pour différents scénarios de cas d’usage

Figure 2 montre comment j’ai mappé comment un utilisateur pourrait réciproques potentiellement (via un énoncé LUIS) avec le robot et comment il doit être interprété comme une intention LUIS spécifique ou une action à effectuer par l’intermédiaire d’Azure, et comment extraire des mots clés (entités LUIS) à partir de l’énoncé LUIS à utiliser en tant que paramètres de requête lors de la recherche.

Figure 2 énoncés et modes de mappage

Conversation ou énoncés	Modes mappés ou des Actions	Qualificateurs ou des paramètres
LUIS à quelque chose ne peut pas interpréter (ou n’est pas formé pour).	None (par défaut)	Non applicable
Get (ou afficher) toutes mes demandes de stratégie.	GetPolicyRequests	Implicite pour l’utilisateur du robot connecté
Je possède une application demande de stratégie, ou est ma demande de stratégie approuvée ?	GetPendingPolicyRequests	Implicite pour les requêtes de stratégie dans laquelle l’état est autre qu’approuvée
M’obtenir les détails du numéro de demande de stratégie VehPolicy001.	GetPolicyRequestDetails	Id de demande de stratégie – VehPolicy001
Obtenir l’état de ma demande de stratégie d’assurance-vie.	GetPolicyRequestStatusByType	Type de demande de stratégie : durée de vie
Obtenir le numéro de document de stratégie Policy0101 émis cette année.	GetPolicyDocument	Fichier nom-Policy0101 et lastmoddate-année en cours
Planification d’une visite du site visitez demain.	ScheduleSiteVisit	Date de l’inspection : demain

Le service LUIS fournit une application Web à luis.ai dans lequel un modèle d’application LUIS peut concerner visuellement le problème en question. Figure 3 affiche le modèle LUIS configuré pour ce scénario.

Figure 3 le modèle LUIS pour mon scénario

Les objectifs, les entités et les énoncés identifiés à l’étape précédente peuvent tous être créés dans l’application LUIS. Utilisez le menu de modes pour ajouter les intentions et le menu entités pour créer les entités. Notez qu’il existe deux types d’entités :

Entités hiérarchiques : Dans ce cas, « Assurance » est créé comme une entité hiérarchique, le parent, avec les différents types, durée de vie, véhicule, accueil et ainsi de suite, créé en tant qu’enfants.
Entités prédéfinies : J’ai utilisé une entité préconfigurée, LUIS fournies appelée Datetime. Paramètres d’entrée tels que l’année d’un document de stratégie a été généré, ou la date lorsque visitez une visite du site est planifié sera mappé par le moteur LUIS à ces types d’entité prédéfinies.

L’entité avec le nom de « Mot clé » pour effectuer une recherche en texte intégral dans l’index de documents de stratégie dans Azure Search.

À présent, sélectionnez le nouvel onglet énoncés et créer des séquences pour chacun des conversations identifiées précédemment et nommez-les.

Pour chaque énoncé, identifier ou étiquette de l’objectif et les entités associées. Par exemple, dans Figure 3, j’ai mappée l’énoncé « m’obtenir l’état de ma demande de stratégie d’assurance-vie, » à l’intention de « GetPolicyRequestStatusByType » et le texte « Assurance vie » à l’entité hiérarchique « Assurance : vie. »

Répétez cette étape pour ajouter d’autres variantes, par exemple lorsque le type de stratégie est le véhicule, accueil ou général. Vous pouvez également les variations où la même requête peut faire d’une manière différente. Toutefois, vous n’êtes pas obligé de capturer chaque permutation et combinaison de méthodes du même message peut être transmise. Par exemple, lorsque j’ajoute un nouvel énoncé comportant l’expression « afficher le statut..., » comme indiqué dans Figure 4, LUIS pourrait bien l’interprète comme une variante du précédent, lequel utilisé « obtenir me le statut... » LUIS apportées les suggestions de droite à l’objectif et les entités associées, même si la question a été demandée d’une manière différente.

Figure 4 étiquetage LUIS énoncés et la gestion des variantes

Une fois que chaque énoncé est capturé, l’application LUIS offre la possibilité pour former le modèle. Ainsi, le moteur d’intelligence artificielle dans LUIS génération de modèles optimisées qui peuvent ensuite être utilisés par les applications clientes. Cette étape doit être répétée à chaque nouvelle énoncés sont étiquetés ou existants sont modifiés.

Publication du modèle LUIS permet d’applications côté client à l’appeler à l’aide d’une API REST. La boîte de dialogue Publier l’application vous permet également de tester le modèle pour vous assurer qu’il fonctionne comme prévu. Figure 5 montre comment tester rapidement le modèle LUIS en passant une expression de conversation et en affichant la sortie dans le navigateur. (Pour plus de commodité, Figure 5 montre les instantanés à partir de trois différentes invocations de séquences et les résultats correspondants côte à côte.)

Test du modèle LUIS
Figure 5 tester le modèle LUIS

Notez que l’objectif recommandée par LUIS a la valeur de probabilité maximale affectée et apparaît en premier dans la liste. Les entités qui ont été extraites de l’expression sont également retournées dans la réponse. S’il y a plusieurs entités identifiées dans l’énoncé, ils seront renvoyés, également. Vous pouvez voir comment le modèle LUIS interprète des termes tels que « cette année » dans l’expression énoncé, est mappé à une entité avant génération « Datetime » et renvoie la valeur « 2016 », l’application cliente peut utiliser directement.

Création de l’Application de robot

Maintenant que le modèle LUIS est prêt, il peut être utilisé dans une application de robot. Téléchargez le modèle de 2015 Visual Studio à partir de aka.ms/bf-bc-vstemplate pour créer l’application. (Visitez bit.ly/2dYrwyW pour apprendre les principes fondamentaux de création d’un robot application et comment utiliser un émulateur de robot pour générer et tester localement le robot.)

Le projet créé lors de l’utilisation de ce modèle est une variante d’un projet MVC. Le point d’entrée pour le projet est MessageController.cs, qui traite les messages entrants à partir de canaux tels que Skype ou marge et envoie les réponses.

Le LUISDialog pour robot Framework est utilisé pour envoyer implicitement les messages de robot au modèle LUIS. Pour chacune des intentions d’implémentée dans le modèle LUIS, une méthode correspondante est implémentée qui peut être appelée directement lorsque l’application bot est en cours d’exécution. Nul besoin de code personnalisé appeler l’API REST LUIS à interpréter la conversation et d’identifier les intentions et les entités.

L’Id d’application LUIS et les valeurs de clé secrètes sont utilisés pour décorer les attributs de niveau classe, à savoir LuisModel. L’attribut LuisIntent est utilisé sur la méthode qui fournit l’implémentation lorsque cette intention est rencontrée dans la demande de l’utilisateur. C’est tout ce qui est nécessaire pour obtenir l’intégration LUIS va dans le robot. Figure 6 illustre comment cela est implémenté dans le code.

Figure 6 implémentation LUIS intégration

[LuisModel("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", 
  "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")]
[Serializable]
  public class PolicyInfoDialogs : LuisDialog<object>
  {
    [LuisIntent("")]
    public async Task None(IDialogContext context, LuisResult result)
    {
      // Called when the incoming utterance is not recognized (default bin)
    }
    [LuisIntent("GetPolicyRequests")]
    public async Task GetPolicyRequests(IDialogContext context, LuisResult result)
    {
      //
    }
        ----------------------
      }

À ce stade, l’implémentation de chacune des méthodes peut être simple ; Je peux simplement retourner un message identifie quelle implémentation LuisIntent a été appelée.

Dans MessageController.cs, ajoutez l’extrait suivant pour capturer le message entrant à partir de l’utilisateur du robot et remettre à le LuisDialog :

if (activity.Type == ActivityTypes.Message)
  {
    await Conversation.SendAsync(activity, () => new PolicyInfoDialog());
  }

Exécutez l’application bot, lancez l’émulateur de canal Bot Framework, qui peut être téléchargé à partir de aka.ms/bf-bc-émulateur. Tapez les énoncés qu'apprentissage du modèle LUIS pour précédemment et vérifiez que le message de réponse indique que la méthode correcte est mappée à l’intention de LUIS a été appelée.

Intégration de la recherche

Maintenant je vais ajouter le SDK Azure Search pour .NET à la solution Visual Studio à l’aide du Gestionnaire de Package NuGet. Le fichier SearchService.cs dans la solution utilise le Kit de développement Logiciel et encapsule tous les intégration avec le Service Azure Search. Il implémente des méthodes pour exécutent des requêtes sur Azure Search, retournent le profil utilisateur du client et récupérer PolicyRequests et PolicyDocuments.

Commandes de recherche pour les différents scénarios sont créés à l’aide de la syntaxe de requête Lucene, qui est implémentée dans le fichier PolicyInfoDialog.cs. Voici quelques exemples :

Récupérer toutes les demandes de stratégie pour l’utilisateur du robot de la conversation :

command += "CustomerId:(" + msftid + ")";
Retrieve all policy requests for the bot user that haven’t yet been approved:
command += "CustomerId:(" + msftid + ") -PolicyStatus:(Approved)";
Query policy requests for the bot user based on the policy request Id:
public async Task GetPolicyRequestDetails(IDialogContext context, LuisResult result)
  {
    ----------------------
      string  command += "CustomerId:(" + msftid + ") AND PolicyRequestId:(" +
        result.Entities[0].Entity + ")";
    ----------------------
  }

L’extrait de code précédent montre comment l’entité PolicyRequestId (les paramètres d’entrée pour exécuter les requêtes de recherche) est passée par le moteur LUIS via LuisResult (résultat).

Figure 7 montre comment implémenter une recherche basée sur une propriété et recherche en texte intégral pour les documents.

Notez que vous voudrez reportez-vous à mon article précédent en rapport avec les noms de propriété et les valeurs dans le Figure 7 code. Vous pouvez également télécharger le schéma de toutes les tables utilisées dans la base de données qui accompagne cet article à l’aide des liens fournis dans les sections suivantes.

Figure 7 implémentation basée sur les propriétés de recherche et de recherche en texte intégral pour les Documents

foreach (EntityRecommendation curEntity in request.Entities)
  {
    switch (curEntity.Type)
      {
        case "PolicyNumber": // Look for documents with this filename
          {
            command += " filename:(" + request.Entities[0].Entity + ") ";
            break;
          }
        case "keyword": // Search within documents for this keyword expression
          {
            command += " " + request.Entities[0].Entity + " ";
            break;
          }
        case "builtin.datetime.date":
        // Retrieve based on the year a document was generated
          {
            char[] delimiterChars = { '.', ':' };
        List<string> allvalues = curEntity.Resolution.Values.ToList<string>();
             string val = allvalues[0];
             string[] vals = val.Split(delimiterChars);
             command += " lastmoddate:(" + vals[0] + ") ";
             break;
          }
        default:
          {
            break;
          }
        }
    }

Mise en forme de la réponse à l’utilisateur

Vous pouvez mettre en forme le texte du message de réponse retourné par le robot de style, ajouter des liens hypertexte ou contenu multimédia et ainsi de suite. Cela permet de renforcer le robot application plus conviviale. Voici quelques exemples de...

Pour définir le style de police gras, uniquement pour les données dynamiques retournées à partir d’Azure Search, placez-le à l’intérieur de deux astérisques (*) :

foreach (SearchResult<PolicyRequest> result in eachGroup)
  {
    searchResponse += (counter) + ". **" + result.Document.PolicyRequestId + "**" +
      " on the insured :**" + result.Document.InsuredIdentifier + "**
      for an amount of :**" +
    result.Document.Currency + " " + result.Document.AssessedValue + "**
      has status: **" +
    result.Document.PolicyStatus + "**\n\n";
    counter++;
  }

Pour ajouter un lien hypertexte à un document de stratégie renvoyé par Azure Search, ajoutez l’attribut de lien à l’URL du document :

foreach (SearchResult<PolicyDocument> result in results)
 {
   searchResponse += counter + ". Link: [" + result.Document.filename + "](" +
     result.Document.fileurl + ") \n";
   counter++;
 }

Identification de l’utilisateur du robot

Le Framework Bot fournit l’Id du canal de l’utilisateur et l’affichage du nom à partir du contexte de conversation, mais ne fournit pas le nom d’utilisateur utilisé pour se connecter dans le canal, tels que Skype. Par conséquent, ces informations doivent être explicitement fournies lorsqu’un utilisateur commence à interagir avec le robot. La boîte de dialogue FormFlow décrit précédemment est utilisé pour inviter l’utilisateur à ces informations. Les informations de profil utilisateur sont extraites d’Azure Search basé sur le nom du compte.

Pour vous assurer que l’utilisateur interagit avec le robot est le propriétaire du nom du compte Microsoft partagé de l’est, vous pouvez intégrer une connexion interactive de la page de connexion Microsoft Account et fournir un accès à robot uniquement après l’authentification et la validation. Cela est hors de portée de l’article. Vous simplement l’utilisateur pour le nom du compte à l’aide de la boîte de dialogue SigninForm et supposons que l’utilisateur est bien celui qu’il prétend être :

public static IForm<SigninForm> BuildForm()
  {
    return new FormBuilder<SigninForm>()
      .Message("I would need some information before we get started.")
      .Field(nameof(MicrosoftAccount))
      .Build();
  }

Stockage du profil utilisateur dans l’état de robot

Une fois que l’utilisateur est identifié au cours de début d’une conversation dans le robot, un objet de profil utilisateur est récupéré à partir d’Azure Search. Ces informations sont stockées dans l’état de robots, à utiliser, par exemple, lorsque l’utilisateur demande qu’une visite du site être planifiée. Le numéro d’adresse et de contact de l’utilisateur est vérifié lors de la confirmation de l’inspection.

Le Framework Bot fournit une API pour stocker ces informations dans le contexte privateConversationData, par l’utilisateur et de conversation, comme indiqué dans Figure 8.

Figure 8 stocker le profil utilisateur

private async Task SignUpComplete(IDialogContext context, IAwaitable<SigninForm> result)
  {
----------------------------------------------
----------------------------------------------
  UserProfile profile =
    await LoadBotUserState(profileIdentityForm.MicrosoftAccount);
  if (profile == null)
  {
  message = $"Sorry, I could not locate your profile in our system.
    Please retry with the right Microsoft Account";
  }
  else
  {
    context.PrivateConversationData.SetValue<bool>("ProfileComplete", true);
    context.PrivateConversationData.SetValue<string>(
      "FirstName", profile.FirstName);
    context.PrivateConversationData.SetValue<string>("LastName", profile.LastName);
    context.PrivateConversationData.SetValue<string>("Address", profile.Address);
    context.PrivateConversationData.SetValue<string>("Phone", profile.Phone);
    context.PrivateConversationData.SetValue<string>(
      "CustomerId", profile.CustomerId);
    message = $"Thanks {profile.LastName},{profile.FirstName}
      for identifying yourself! \n\n
      Let me know how I could assist you.";
  }
    await context.PostAsync(message);
  }
    context.Wait(MessageReceived);
  }

Pour chaque demande, l’application de robot vérifie avec l’état de robot pour vous assurer que l’identité de l’utilisateur qui émet la demande est vérifiée et les informations de profil utilisateur ne soient disponibles.

À l’aide de l’émulateur de canal de robot localement

L’application bot nécessite de l’espace de noms Azure Search, clé d’accès et le nom de l’index à utiliser pour exécuter les demandes de l’utilisateur. Ces paramètres sont stockés dans le fichier SearchParameters.cs, et leurs valeurs définies à partir du fichier web.config lors de l’exécution de l’application de robot. Vous pouvez maintenant exécuter la solution Visual Studio.

Lancez l’émulateur de canal Bot, puis entrez l’apprentissage du modèle LUIS pour les conversations. Un scénario d’interaction utilisateur classique est capturé dans Figure 9. Une fois que l’application bot s’exécute correctement dans l’environnement local, il peut être publié vers une application Web Azure.

Figure 9 à partir d’un émulateur en cours d’exécution du robot

Déploiement de robot sur Azure

Créer une application Web dans Azure à partir du portail Azure, puis, dans les paramètres d’Application, ajoutez appSetting clés et valeurs du fichier web.config dans la solution Visual Studio.

Avant de publier l’application robot à une application Web Azure, vous devez inscrire ce robot à dev.botframework.com/bots/new. Ce processus génère un ID Bot, un ID d’application Microsoft et un Secret. Ajoutez ces valeurs au fichier web.config de l’application bot dans Visual Studio 2015, puis republier cette application dans Azure.

Pendant le processus d’inscription pour le paramètre d’URL de redirection, utilisez l’URL SSL activé de l’application bot dans Azure et le suffixe « / api/messages. »

L’activation de robot via des canaux

Dans le Registre Bot dev.botframework.com/bots, vous pouvez activer le robot sur d’autres chaînes. Figure 10 montre l’application bot activée sur les canaux Skype et la marge. Activation de l’application de robot pour Slack requiert quelques étapes supplémentaires. Un Assistant est lancé lorsque vous choisissez d’ajouter robot à ce canal, qui vous guidera à travers les étapes appropriées.

Figure 10 l’inscription du robot sur plusieurs canaux

Figure 11 montre le robot application à partir de Skype.

Figure 11 l’accès à l’outil de Skype

Pour résumer

Microsoft Bot Framework et autres technologies de prise en charge tels que LUIS et Azure Search offrent les meilleures bases pour créer des applications qui permettent aux clients de robot intuitive interagissent avec vos applications line-of-business. La façon de chacun de ces services s’intègrent l’architecture globale de la solution permet de s’assurer que les composants individuels peuvent être maturation ou améliorées indépendants des autres. Par exemple, le modèle LUIS peut être modifié pour prendre en charge les séquences de plus que les utilisateurs pourront utiliser pour interagir avec le robot, tout en n’entraînant aucune modification sur l’application de robot de base ou le contenu dans Azure Search. Une fois déployée, une application de robot peut, sans aucune modification de code supplémentaire, être activée pour l’accès à partir de divers canaux, et plus de canaux peuvent être ajoutés au fil du temps, pour augmenter la portée et l’utilisation de l’application de robot.

Srikantan Sankaranest un spécialiste technique de l’équipe DX en Inde, basé à Bangalore. Il travaille avec nombreux éditeurs de logiciels en Inde et leur permet de concevoir et déployer leurs solutions sur Microsoft Azure. Contactez-le à sansri@microsoft.com.

Merci aux experts techniques Microsoft suivants d'avoir relu cet article : Sandeep Alur et Hemanth Kathuria
Sandeep Alur est le développeur de conduire pour l’Inde DX, basé à Bangalore.

Hemanth Kathuria est Consultant Senior dans l’équipe des Services en Inde