talkify
1.0.0
Framework pour développer des applications de chatbot.
Assurez-vous que node et npm sont installés. À partir de maintenant, ce module a été testé sur la version 0.12 du nœud dans le pipeline Travis CI.
Exécutez simplement la commande npm install pour installer :
npm install --save talkifyNécessite le module principal, les types et les dépendances. La commande suivante charge tout ce dont vous avez besoin à partir du module.
// Core dependency
const talkify = require ( 'talkify' ) ;
const Bot = talkify . Bot ;
// Types dependencies
const BotTypes = talkify . BotTypes ;
const Message = BotTypes . Message ;
const SingleLineMessage = BotTypes . SingleLineMessage ;
const MultiLineMessage = BotTypes . MultiLineMessage ;
// Skills dependencies
const Skill = BotTypes . Skill ;
// Training dependencies
const TrainingDocument = BotTypes . TrainingDocument ;Une fois les dépendances chargées, vous pouvez initialiser le core du bot.
const bot = new Bot ( ) ; Le constructeur Bot() accepte également des paramètres sous forme d'objet de configuration. Ici, vous pouvez transmettre des valeurs de commutateur de configuration ou des implémentations alternatives pour des éléments tels que ContextStore et Classifier , etc. Nous aborderons cela plus tard dans la section Options de configuration.
Une fois le Bot initialisé, la première chose à faire est de le former. Pour l'entraîner un document à la fois de manière synchrone, vous pouvez utiliser la méthode train :
bot . trainAll ( [
new TrainingDocument ( 'how_are_you' , 'how are you' ) ,
new TrainingDocument ( 'how_are_you' , 'how are you going' ) ,
new TrainingDocument ( 'how_are_you' , 'how is it going' ) ,
new TrainingDocument ( 'help' , 'how can you help' ) ,
new TrainingDocument ( 'help' , 'i need some help' ) ,
new TrainingDocument ( 'help' , 'how could you assist me' )
] , function ( ) { } ) ; Le code ci-dessus entraîne le bot à reconnaître le sujet how_are_you lorsque le texte ressemble à how are you ou how are you doing ainsi que how is it going mais à reconnaître help du sujet lorsque le texte ressemble à how can you help ou i need some help ainsi que how can you assist me . C'est ainsi que vous entraîneriez le bot.
La méthode trainAll accepte un tableau d'objets TrainingDocument ainsi qu'une fonction de rappel. Le constructeur d'objet TrainingDocument accepte deux paramètres. Ce sont topicName et trainingData . Le paramètre topicName est le nom du sujet pour lequel vous souhaitez entraîner le trainingData et trainingData est la phrase que vous fournissez au bot comme données d'entraînement. Le topicName sera ensuite mappé aux compétences réelles auxquelles le bot peut répondre.
Le rappel de la méthode trainAll est une fonction que le bot peut appeler une fois la formation terminée. Si vous disposez de trop de données d’entraînement, vous devez les mettre en œuvre correctement. Dans cet exemple, comme il n'y a pas beaucoup de données d'entraînement, nous avons transmis une function vide.
Inutile de dire que le bot s'améliore avec plus de données d'entraînement. Dans ce didacticiel, nous utilisons le classificateur par défaut, qui est actuellement le classificateur LogisticRegression de la bibliothèque talkify-natural-classifier. Ce classificateur nécessite généralement un peu plus de données d'entraînement au départ, mais il est plus précis que les autres dans la plupart des conditions.
Une fois que vous avez formé le bot sur certains sujets, vous devez ajouter quelques compétences. Les compétences sont des actions que le bot exécutera lorsqu'il reconnaît un sujet. Les sujets et les compétences correspondent donc à un rapport 1:1.
Pour ajouter une compétence, vous devez d'abord la créer. Une compétence nécessite trois choses. Nom de la compétence propre au bot. Le nom est utilisé plus tard pour relier les compétences dans le contexte. Un sujet auquel il correspond et une fonction que le bot appellera afin d'exécuter la compétence. Cette fonction prendra quatre paramètres, à savoir : context, request, response, next . Le paramètre context est utilisé pour stocker toute information contextuelle utile de cette compétence. Le paramètre request contient des informations sur la requête, idem pour response . Le paramètre next est une fonction que vous pouvez appeler pour informer le bot que vous avez terminé le traitement. Voici à quoi ressemble une compétence :
var howAction = function ( context , request , response , next ) {
response . message = new SingleLineMessage ( 'You asked: "' + request . message . content + '". I'm doing well. Thanks for asking.' ) ;
next ( ) ;
} ;
var helpAction = function ( context , request , response , next ) {
response . message = new SingleLineMessage ( 'You asked: "' + request . message . content + '". I can tell you how I'm doing if you ask nicely.' ) ;
next ( ) ;
} ;
var howSkill = new Skill ( 'how_skill' , 'how_are_you' , howAction ) ;
var helpSkill = new Skill ( 'help_skill' , 'help' , helpAction ) ;Remarque : Le nom d'une compétence peut être indéfini. Cependant, sachez que cela signifie que le bot exécutera cette compétence chaque fois que son niveau de confiance est de 0 pour répondre à une requête donnée.
Une fois que vous avez défini certaines compétences, vous devez les ajouter au bot. Ajoutez la compétence au bot comme ceci :
bot . addSkill ( howSkill ) ;
bot . addSkill ( helpSkill ) ; Une fois ajouté, vous pouvez maintenant demander au bot de résoudre quelque chose. C'est ici que vous interrogez le bot avec une phrase et il répondra par un message de manière asynchrone. La fonction de résolution prend trois paramètres : contextId, text, callback . Le contextId aide le bot à résoudre le contexte de toute conversation précédente. Le text est la question ou le morceau de chaîne en langage naturel que le robot doit interpréter et auquel il doit répondre. Enfin, le callback est la fonction de rappel que le bot appellera avec err, messages pour indiquer une erreur (le cas échéant) et ses messages de réponse.
var resolved = function ( err , messages ) {
if ( err ) return console . error ( err ) ;
return console . log ( messages ) ;
} ;
bot . resolve ( 123 , 'Assistance required' , resolved ) ;Exécutez-le comme un simple fichier de nœud et il devrait imprimer ce qui suit dans la console.
[ { type: 'SingleLine',
content: 'You asked: "Assistance required". I can tell you how I'm doing if you ask nicely.' } ]
Essayez de remplacer bot.resolve par ceci et notez le changement en réponse.
bot . resolve ( 456 , 'How's it going?' , resolved ) ; Posons deux choses à la fois. Remplacez à nouveau bot.resolve par :
bot . resolve ( 456 , 'How's it going? Assistance required please.' , resolved ) ;Lorsque vous exécutez votre code, vous devriez recevoir deux messages :
[ { type : 'SingleLine' ,
content : 'You asked: "How's it going? Assistance required please.". I'm doing well. Thanks for asking.' } ,
{ type : 'SingleLine' ,
content : 'You asked: "How's it going? Assistance required please.". I can tell you how I'm doing if you ask nicely.' } ] Actuellement, les méthodes train , addSkill et resolve peuvent être chaînées. Cela signifie que vous pouvez créer des objets Bot et des méthodes en cascade comme mentionné ci-dessous.
new Bot ( ) . train ( topic , sentence ) . addSkill ( skill ) . resolve ( ... . ) Le noyau du bot accepte également une implémentation alternative pour le magasin de contexte intégré. Veuillez consulter Gestion du contexte pour plus de détails.
Vous pouvez également fournir votre propre version du classificateur au bot. Cette option a été principalement utilisée pour faciliter les tests, cependant, elle peut toujours être utilisée en production si vous disposez d'une meilleure version du classificateur intégré.
Le classificateur intégré est le classificateur talkify-natural-. Ce classificateur fournit deux implémentations :
LogisticRegressionClassifierBayesClassifier LogisticRegressionClassifier est le classificateur par défaut. Si vous préférez implémenter le BayesClassifier à partir de talkify-natural-classifier , vous pouvez procéder comme suit :
var BayesClassifier = require ( 'talkify-natural-classifier' ) . BayesClassifier ;
var bot = new Bot ( { classifier : new BayesClassifier ( ) } ) ;Si vous préférez utiliser le classificateur de traitement du langage naturel d'IBM Watson, vous devez plutôt utiliser la bibliothèque talkify-watson-classifier. Veuillez consulter le guide sur la page du référentiel Github pour plus de détails sur la façon d'utiliser ce classificateur.
Si vous pensez que le vôtre fonctionne mieux, faites-moi signe ! Je serais ravi de le savoir et éventuellement de travailler à sa mise en œuvre dans le module de base.
Pour fournir votre propre implémentation de Skill Resolution Strategy, transmettez simplement la définition de la fonction dans l'objet de configuration comme suit :
var mySkillResolutionStrategy = function ( ) {
this . addSkill = function ( skill , options ) { ... } ;
this . getSkills = function ( ) { ... } ;
this . resolve = function ( err , resolutionContext , callback ) {
...
} ;
return this ;
} ;
var bot = new Bot ( {
skillResolutionStrategy : mySkillResolutionStrategy
} ) ;Le noyau du bot créera une instance de votre objet de stratégie de résolution de compétences lors de l'initialisation et l'utilisera comme instance unique dans toutes les résolutions.
Pour fournir votre propre implémentation de la stratégie de résolution de sujets, transmettez simplement la définition de la fonction dans l'objet de configuration comme suit :
var myTopicResolutionStrategy = function ( ) {
this . collect = function ( classification , classificationContext , callback ) { callback ( ) } ;
this . resolve = function ( callback ) { callback ( [ { name : "topic_name" , confidence : 0.5 ] ) } ;
return this ;
} ;
var bot = new Bot ( {
topicResolutionStrategy : myTopicResolutionStrategy
} ) ;Le cœur du bot créera une nouvelle instance de votre stratégie de résolution de sujet pour chaque appel qu'il reçoit dans la méthode de résolution.
Par défaut, le noyau du bot utilise sa version intégrée de ContextStore. Si vous examinez lib/ContextStore.js, vous constaterez qu'il s'agit d'une implémentation très simple dans laquelle le contexte est stocké dans une simple carte en mémoire, le contextId étant la clé et l'objet de contexte étant la valeur. Bien sûr, lorsque vous déployerez cela, le magasin de contexte intégré sera très limitatif.
L'extension du magasin de contexte est très simple. Dans la configuration, vous pouvez fournir votre propre implémentation pour l'objet ContextStore. Le code suivant fournit une implémentation très triviale qui enregistre simplement les valeurs sur la console.
var myContextStore = {
put : function ( id , context , callback ) {
console . info ( 'put' ) ;
console . info ( id ) ;
console . info ( context ) ;
} ,
get : function ( id , callback ) {
console . info ( 'get' ) ;
console . info ( id ) ;
} ,
remove : function ( id , callback ) {
console . info ( 'remove' ) ;
console . info ( id ) ;
}
}
var bot = new Bot ( { contextStore : myContextStore } ) ; La spécification actuelle de ContextStore nécessite la mise en œuvre de trois fonctions. Ceux-ci sont put, get and remove . Tant que ces méthodes sont fournies, le bot ne se soucie pas d'où vient la valeur du champ contextStore dans la configuration.
Si vous deviez exécuter ce code avec certaines résolutions de requêtes, vous constaterez que la fonction de suppression n'est jamais appelée. Il s'agit d'un travail en cours car il n'y a actuellement aucune limite quant à la durée pendant laquelle un contexte doit être mémorisé.
Comme mentionné précédemment, le classificateur par défaut utilisé par le bot provient de la bibliothèque talkify-natural-classifier. Vous êtes libre d'écrire votre propre classificateur et de l'utiliser dans votre application. Pour ce faire, vous devez étendre l'interface du classificateur définie dans la bibliothèque talkify-classifier.
Une fois que vous avez étendu avec succès cette implémentation, vous pouvez fournir votre classificateur au bot comme ceci :
var myClassifier = new MyAwesomeClassifier ( ) ;
var bot = new Bot ( { classifier : myClassifier } ) ;J'aimerais voir votre implémentation du classificateur talkify. Si vous avez étendu l'interface et implémenté avec succès votre classificateur, faites-moi signe ! Je serais ravi de connaître votre expérience en utilisant cette bibliothèque.
Depuis la version 2.1.0, vous pouvez spécifier plusieurs classificateurs pour votre bot. Voir la documentation sur le classificateur pour plus d'informations.
Une stratégie de résolution de compétences est un composant capable de générer une compétence, étant donné un contexte de résolution. Un contexte de résolution est un objet composé d'une liste de sujets et de la phrase originale, ingrédients essentiels nécessaires à la résolution d'une compétence.
+-------------+
| Topic | | |
+---------+ | +----> +--------------+
|-----------+ | | |
+-------------+ | Skill | +---------+
| Resolution +----> | Skill |
| Strategy | +---------+
+------------+ | |
| Sentence | +---> +--------------+
+------------+
Une stratégie de résolution de sujet vous permet d'intégrer une logique personnalisée pour résoudre un sujet, en fonction des données de classification. Lors de la connexion d'une stratégie de résolution de sujet personnalisée, le cœur du bot s'attend à ce que la définition de la fonction soit transmise au lieu du résultat de l'exécution de la fonction. En effet, l'objet de stratégie de résolution de sujet est construit en utilisant new pour chaque appel à la méthode resolve .
Le processus de résolution de sujet fonctionne en deux parties :
La première étape du processus de résolution du sujet est la phase de collecte. Ici, le noyau du bot envoie la classification pour chaque ensemble de classification renvoyé par le classificateur ainsi que tout contexte requis. Le cœur du bot transmet également une fonction de rappel qui doit être invoquée pour informer le cœur du bot que l'invocation a réussi.
+------------------+ +
| Classification | |
+------------------+ |
| +-----------+
+--------> Collect |
| +-----------+
+-----------+ |
| Context | |
+-----------+ +
La deuxième étape est la phase de résolution. Ici, le noyau du bot s’attend à ce qu’une liste de classifications soit renvoyée. La résolution n’est appelée qu’une fois l’exécution de toutes les collections terminée.
+-----------+ +---------+-+-+
| Resolve +---->+ Topic | | |
+-----------+ +---------+ | |
|-----------+ |
+-------------+
Un objet de stratégie de résolution de sujet doit exposer deux méthodes :
La méthode collect est appelée chaque fois qu'un classificateur renvoie une ou plusieurs classifications. Il est appelé avec classification, context, callback . L'objet classification contient la classification renvoyée par le classificateur (ou l'ensemble de classificateurs si vous utilisez des quorums). L'objet context est l'objet contenant le contexte de la requête. Le dernier callback de paramètre est la fonction qui doit être invoquée pour informer le cœur du bot que vous avez fini de collecter les paramètres transmis.
La méthode de résolution est appelée une fois que le noyau du bot a fini d'appeler collect sur votre stratégie de résolution de sujet. Il s'agit du dernier appel du noyau du bot et est destiné à collecter des informations sur la résolution du sujet. La méthode resolve est appelée avec un paramètre callback . Il s'agit de la fonction de rappel qui doit être appelée avec error, topics . Le paramètre error doit être défini comme un objet d'erreur au cas où une erreur se produirait lors de la résolution du sujet. Dans tous les autres cas, cet objet doit être undefined . Le deuxième paramètre topics doit être un tableau de sujets résolus par la stratégie de résolution.
Veuillez consulter le guide de contribution pour plus de détails.
