talkify
1.0.0
Framework zur Entwicklung von Chat-Bot-Anwendungen.
Stellen Sie sicher, dass Node und NPM installiert sind. Derzeit wurde dieses Modul mit der Knotenversion 0,12 innerhalb der Travis CI-Pipeline getestet.
Führen Sie einfach den Befehl npm install aus, um Folgendes zu installieren:
npm install --save talkifyErfordert das Hauptmodul, die Typen und Abhängigkeiten. Der folgende Befehl lädt alles, was Sie benötigen, aus dem Modul.
// 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 ;Sobald die Abhängigkeiten geladen wurden, können Sie den Bot-Kern initialisieren.
const bot = new Bot ( ) ; Der Bot() Konstruktor akzeptiert auch Parameter in Form von Konfigurationsobjekten. Hier können Sie Konfigurationsschalterwerte oder alternative Implementierungen für Dinge wie ContextStore und Classifier usw. übergeben. Darauf gehen wir später im Abschnitt „Konfigurationsoptionen“ ein.
Sobald der Bot initialisiert wurde, sollten Sie ihn zunächst trainieren. Um es jeweils dokumentweise synchron zu trainieren, können Sie die train -Methode verwenden:
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 ( ) { } ) ; Der obige Code trainiert den Bot, das Thema how_are_you zu erkennen, wenn der Text wie how are you oder how are you doing und how is it going dir“ aussieht, zu erkennen, aber die help zu erkennen, wenn der Text wie how can you help oder i need some help aussieht und how can you assist me . So würden Sie den Bot trainieren.
Die trainAll -Methode akzeptiert ein Array von TrainingDocument Objekten sowie eine Rückruffunktion. Der TrainingDocument Objektkonstruktor akzeptiert zwei Parameter. Dies sind topicName und trainingData . Der Parameter topicName ist der Name des Themas, für das Sie die trainingData trainieren möchten, und „ trainingData ist der Satz, den Sie dem Bot als Trainingsdaten zuführen. Der topicName wird später den tatsächlichen Fähigkeiten zugeordnet, auf die der Bot reagieren kann.
Der Rückruf für die trainAll -Methode ist eine Funktion, die der Bot aufrufen kann, wenn das Training abgeschlossen ist. Wenn Sie zu viele Trainingsdaten haben, sollten Sie dies richtig implementieren. Da in diesem Beispiel nicht viele Trainingsdaten vorhanden sind, haben wir eine leere function übergeben.
Es versteht sich von selbst, dass der Bot mit mehr Trainingsdaten besser wird. In diesem Tutorial verwenden wir den Standardklassifikator, derzeit der LogisticRegression Klassifikator aus der Talkify-Natural-Classifier-Bibliothek. Dieser Klassifikator benötigt in der Regel zunächst etwas mehr Trainingsdaten, ist aber unter den meisten Bedingungen genauer als andere.
Nachdem Sie den Bot für einige Themen trainiert haben, müssen Sie einige Fähigkeiten hinzufügen. Fähigkeiten sind Aktionen, die der Bot ausführt, wenn er ein Thema erkennt. So werden Themen und Kompetenzen 1:1 abgebildet.
Um eine Fertigkeit hinzuzufügen, müssen Sie sie zuerst erstellen. Eine Fähigkeit erfordert drei Dinge. Name der Fähigkeit, die für den Bot einzigartig ist. Der Name wird verwendet, um Fähigkeiten später im Kontext in Beziehung zu setzen. Ein Thema, dem er zugeordnet ist, und eine Funktion, die der Bot aufruft, um den Skill auszuführen. Diese Funktion benötigt vier Parameter, nämlich: context, request, response, next . Der context wird zum Speichern aller nützlichen Kontextinformationen aus diesem Skill verwendet. Der request enthält Informationen über die Anforderung, dasselbe gilt für response . Der next Parameter ist eine Funktion, die Sie aufrufen können, um dem Bot mitzuteilen, dass Sie mit der Verarbeitung fertig sind. So sieht eine Fertigkeit aus:
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 ) ;Hinweis: Der Name einer Fertigkeit kann undefiniert sein. Bitte beachten Sie jedoch, dass dies bedeutet, dass der Bot diesen Skill immer dann ausführt, wenn sein Konfidenzniveau für die Beantwortung einer bestimmten Anfrage 0 ist.
Nachdem Sie einige Fähigkeiten definiert haben, müssen Sie sie dem Bot hinzufügen. Fügen Sie den Skill wie folgt zum Bot hinzu:
bot . addSkill ( howSkill ) ;
bot . addSkill ( helpSkill ) ; Nach dem Hinzufügen können Sie den Bot nun bitten, etwas zu lösen. Hier fragen Sie den Bot mit einem Satz ab und er antwortet asynchron mit einer Nachricht. Die Auflösungsfunktion akzeptiert drei Parameter: contextId, text, callback . Die contextId hilft dem Bot, den Kontext aus früheren Konversationen aufzulösen. Der text ist die Frage oder ein Teil einer Zeichenfolge in natürlicher Sprache, die der Bot interpretieren und beantworten muss. Schließlich ist der callback die Rückruffunktion, die der Bot mit err, messages Nachrichtenparametern zur Anzeige eines Fehlers (falls vorhanden) und seinen Antwortnachrichten aufruft.
var resolved = function ( err , messages ) {
if ( err ) return console . error ( err ) ;
return console . log ( messages ) ;
} ;
bot . resolve ( 123 , 'Assistance required' , resolved ) ;Führen Sie es wie eine einfache Knotendatei aus und es sollte Folgendes in der Konsole ausgeben.
[ { type: 'SingleLine',
content: 'You asked: "Assistance required". I can tell you how I'm doing if you ask nicely.' } ]
Versuchen Sie, bot.resolve in diesen Wert zu ändern, und bemerken Sie die Änderung in der Antwort.
bot . resolve ( 456 , 'How's it going?' , resolved ) ; Fragen wir zwei Dinge gleichzeitig. Ändern Sie bot.resolve erneut in:
bot . resolve ( 456 , 'How's it going? Assistance required please.' , resolved ) ;Wenn Sie Ihren Code ausführen, sollten Sie zwei Meldungen zurückerhalten:
[ { 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.' } ] Derzeit sind die Methoden train , addSkill und resolve verkettbar. Das bedeutet, dass Sie Bot-Objekte erstellen und Methoden kaskadieren können, wie unten beschrieben.
new Bot ( ) . train ( topic , sentence ) . addSkill ( skill ) . resolve ( ... . ) Der Bot-Kern akzeptiert auch eine alternative Implementierung für den integrierten Kontextspeicher. Weitere Informationen finden Sie unter Kontextverwaltung.
Sie können dem Bot auch Ihre eigene Version des Klassifikators bereitstellen. Diese Option wurde hauptsächlich verwendet, um das Testen zu vereinfachen. Sie kann jedoch weiterhin in der Produktion verwendet werden, wenn Sie über eine bessere Version des integrierten Klassifikators verfügen.
Der eingebaute Klassifikator ist der talkify-natural-classifier. Dieser Klassifikator bietet zwei Implementierungen:
LogisticRegressionClassifierBayesClassifier Der LogisticRegressionClassifier ist der Standardklassifikator. Wenn Sie lieber den BayesClassifier von talkify-natural-classifier implementieren möchten, können Sie Folgendes tun:
var BayesClassifier = require ( 'talkify-natural-classifier' ) . BayesClassifier ;
var bot = new Bot ( { classifier : new BayesClassifier ( ) } ) ;Wenn Sie stattdessen lieber den Natural Language Processing Classifier von IBM Watson verwenden möchten, sollten Sie stattdessen die Bibliothek talkify-watson-classifier verwenden. Weitere Informationen zur Verwendung dieses Klassifikators finden Sie in der Anleitung auf der Github-Repository-Seite.
Wenn Sie der Meinung sind, dass Ihre besser funktionieren, rufen Sie mich an! Ich würde mich freuen, dies zu erfahren und möglicherweise darauf hinzuarbeiten, es im Kernmodul umzusetzen.
Um Ihre eigene Implementierung der Skill Resolution Strategy bereitzustellen, übergeben Sie einfach die Funktionsdefinition wie folgt im Konfigurationsobjekt:
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
} ) ;Der Bot-Kern erstellt auf init eine Instanz Ihres Skill-Auflösungsstrategieobjekts und verwendet es als einzelne Instanz für alle Auflösungen.
Um Ihre eigene Implementierung der Topic Resolution Strategy bereitzustellen, übergeben Sie einfach die Funktionsdefinition wie folgt im Konfigurationsobjekt:
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
} ) ;Der Bot-Kern erstellt für jeden Aufruf der Auflösungsmethode eine neue Instanz Ihrer Themenlösungsstrategie.
Standardmäßig verwendet der Bot-Kern seine integrierte Version von ContextStore. Wenn Sie sich lib/ContextStore.js ansehen, werden Sie feststellen, dass es sich um eine sehr einfache Implementierung handelt, bei der der Kontext in einer einfachen In-Memory-Map gespeichert wird, wobei die contextId der Schlüssel und das Kontextobjekt der Wert ist. Wenn Sie dies bereitstellen, wird der integrierte Kontextspeicher natürlich sehr einschränkend sein.
Das Erweitern des Kontextspeichers ist sehr einfach. Innerhalb der Konfiguration können Sie Ihre eigene Implementierung für das ContextStore-Objekt bereitstellen. Der folgende Code stellt eine sehr triviale Implementierung bereit, die die Werte einfach in der Konsole protokolliert.
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 } ) ; Die aktuelle Spezifikation für ContextStore erfordert die Implementierung von drei Funktionen. Diese werden put, get and remove . Solange diese Methoden bereitgestellt werden, ist es dem Bot egal, woher der Wert für contextStore Feld in der Konfiguration kommt.
Wenn Sie diesen Code mit einigen Abfrageauflösungen ausführen, werden Sie feststellen, dass die Remove-Funktion nie aufgerufen wird. Dies ist noch in Arbeit, da es derzeit keine Begrenzung gibt, wie lange ein Kontext gespeichert werden muss.
Wie bereits erwähnt, stammt der vom Bot verwendete Standardklassifikator aus der Talkify-Natural-Classifier-Bibliothek. Es steht Ihnen frei, Ihren eigenen Klassifikator zu schreiben und ihn in Ihrer Anwendung zu verwenden. Dazu müssen Sie die in der Talkify-Classifier-Bibliothek definierte Klassifikatorschnittstelle erweitern.
Sobald Sie diese Implementierung erfolgreich erweitert haben, können Sie Ihren Klassifikator wie folgt an den Bot übergeben:
var myClassifier = new MyAwesomeClassifier ( ) ;
var bot = new Bot ( { classifier : myClassifier } ) ;Ich würde gerne Ihre Implementierung des Talkify-Klassifikators sehen. Wenn Sie die Schnittstelle erweitert und Ihren Klassifikator erfolgreich implementiert haben, rufen Sie mich an! Ich würde mich über Ihre Erfahrungen mit dieser Bibliothek freuen.
Seit Version 2.1.0 können Sie mehrere Klassifikatoren für Ihren Bot angeben. Weitere Informationen finden Sie in der Dokumentation zum Klassifikator.
Eine Skill-Auflösungsstrategie ist eine Komponente, die in der Lage ist, einen Skill in einem gegebenen Auflösungskontext auszugeben. Ein Lösungskontext ist ein Objekt, das aus einer Liste von Themen und dem Originalsatz besteht, den wesentlichen Bestandteilen, die zum Lösen einer Fertigkeit erforderlich sind.
+-------------+
| Topic | | |
+---------+ | +----> +--------------+
|-----------+ | | |
+-------------+ | Skill | +---------+
| Resolution +----> | Skill |
| Strategy | +---------+
+------------+ | |
| Sentence | +---> +--------------+
+------------+
Mit einer Themenlösungsstrategie können Sie benutzerdefinierte Logik integrieren, um ein Thema anhand der Klassifizierungsdaten aufzulösen. Beim Einbinden einer benutzerdefinierten Themenauflösungsstrategie erwartet der Bot-Kern, dass die Funktionsdefinition anstelle des Ergebnisses der Funktionsausführung übergeben wird. Dies liegt daran, dass das Themenauflösungsstrategieobjekt für jeden Aufruf der resolve mit new erstellt wird.
Der Prozess der Themenlösung erfolgt in zwei Teilen:
Die erste Phase des Themenlösungsprozesses ist die Sammlungsphase. Hier sendet der Bot-Kern die Klassifizierung für jeden vom Klassifikator zurückgegebenen Klassifizierungssatz zusammen mit dem erforderlichen Kontext. Der Bot-Kern übergibt außerdem eine Rückruffunktion, die aufgerufen werden muss, um dem Bot-Kern mitzuteilen, dass der Aufruf erfolgreich war.
+------------------+ +
| Classification | |
+------------------+ |
| +-----------+
+--------> Collect |
| +-----------+
+-----------+ |
| Context | |
+-----------+ +
Die zweite Stufe ist die Lösungsphase. Hier erwartet der Bot-Kern die Rückgabe einer Liste von Klassifizierungen. Die Auflösung wird erst aufgerufen, nachdem die Ausführung aller Sammlungen abgeschlossen ist.
+-----------+ +---------+-+-+
| Resolve +---->+ Topic | | |
+-----------+ +---------+ | |
|-----------+ |
+-------------+
Ein Themenlösungsstrategieobjekt muss zwei Methoden verfügbar machen:
Die Collect-Methode wird jedes Mal aufgerufen, wenn ein Klassifikator Klassifizierung(en) zurückgibt. Es wird mit classification, context, callback aufgerufen. Das classification enthält die vom Klassifikator zurückgegebene Klassifizierung (oder eine Gruppe von Klassifikatoren, wenn Quoren verwendet werden). Das context ist das Objekt, das den Anforderungskontext enthält. Der letzte callback ist die Funktion, die aufgerufen werden muss, um dem Bot-Kern mitzuteilen, dass Sie mit der Erfassung der übergebenen Parameter fertig sind.
Die Auflösungsmethode wird einmal aufgerufen, nachdem der Bot-Kern mit dem Aufruf von collect für Ihre Themenauflösungsstrategie fertig ist. Dies ist der letzte Aufruf des Bot-Kerns und dient dazu, Informationen zur Themenlösung zu sammeln. Die resolve wird mit einem callback -Parameter aufgerufen. Dies ist die Rückruffunktion, die mit den beiden Parametern error, topics aufgerufen werden muss. Der Fehlerparameter muss als Fehlerobjekt definiert werden, falls beim Auflösen des Themas ein Fehler aufgetreten ist. In allen anderen Fällen muss dieses Objekt undefined sein. Der zweite topics muss ein Array von Themen sein, die durch die Lösungsstrategie gelöst werden.
Weitere Einzelheiten finden Sie im Beitragsleitfaden.
