talkify

พูดจา

กรอบการทำงานสำหรับการพัฒนาแอพพลิเคชั่นแชทบอท

• การใช้งาน
  • ตั้งค่า
  • การสอนโค้ด
    • เริ่มต้น
    • รถไฟ
    • เพิ่มทักษะ
    • แก้ไขข้อสงสัย
    • วิธีการแบบล่ามโซ่
  • ตัวเลือกการกำหนดค่า
    • ร้านค้าบริบท
    • ลักษณนาม
  • การขยายบอท
    • การจัดการบริบท
    • ลักษณนามที่กำหนดเอง
• เอกสารอ้างอิง
• มีส่วนร่วม

การใช้งาน

ตั้งค่า

ตรวจสอบให้แน่ใจว่าคุณได้ติดตั้งโหนดและ npm แล้ว ณ ขณะนี้ โมดูลนี้ได้รับการทดสอบกับเวอร์ชันโหนด 0.12 ภายในไปป์ไลน์ Travis CI

เพียงรันคำสั่ง npm install เพื่อติดตั้ง:

npm install --save talkify

การสอนโค้ด

เริ่มต้น

ต้องการโมดูลหลัก ประเภท และการขึ้นต่อกัน คำสั่งต่อไปนี้จะโหลดทุกสิ่งที่คุณต้องการจากโมดูล

 // 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 ;

เมื่อโหลดการขึ้นต่อกันแล้ว คุณสามารถเริ่มต้นแกนหลักของบอทได้

 const bot = new Bot ( ) ;

ตัวสร้าง Bot() ยังยอมรับพารามิเตอร์ในรูปแบบของวัตถุการกำหนดค่า ที่นี่คุณสามารถส่งผ่านค่าสวิตช์การกำหนดค่าหรือการใช้งานทางเลือกสำหรับสิ่งต่างๆ เช่น ContextStore และ Classifier เป็นต้น เราจะกล่าวถึงในภายหลังในส่วนตัวเลือกการกำหนดค่า

รถไฟ

เมื่อเริ่มต้น Bot แล้ว สิ่งแรกที่คุณควรทำคือฝึกฝนมัน หากต้องการฝึกเอกสารครั้งละหนึ่งเอกสารพร้อมกัน คุณสามารถใช้วิธี 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 ( ) { } ) ;

โค้ดด้านบนฝึกให้บอทจดจำหัวข้อ how_are_you เมื่อข้อความดูเหมือนว่า how are you หรือ how are you doing และ how is it going แต่จะรับรู้ถึง help ในหัวข้อ เมื่อข้อความดูเหมือนว่า how can you help หรือ i need some help รวมทั้ง how can you assist me นี่คือวิธีที่คุณจะฝึกบอท

เมธอด trainAll ยอมรับอาร์เรย์ของออบเจ็กต์ TrainingDocument รวมถึงฟังก์ชันโทรกลับ ตัวสร้างออบเจ็กต์ TrainingDocument ยอมรับพารามิเตอร์สองตัว เหล่านี้คือ topicName และ trainingData พารามิเตอร์ topicName คือชื่อของหัวข้อที่คุณต้องการฝึก trainingData และ trainingData คือประโยคที่คุณป้อนให้บอทเป็นข้อมูลการฝึก topicName จะแสดงบนแผนที่ตามทักษะจริงที่บอทสามารถตอบสนองได้ในภายหลัง

การเรียกกลับสำหรับเมธอด trainAll เป็นฟังก์ชันที่บอทสามารถเรียกได้เมื่อการฝึกเสร็จสมบูรณ์ หากคุณมีข้อมูลการฝึกอบรมมากเกินไป คุณควรใช้ข้อมูลนี้อย่างเหมาะสม ในตัวอย่างนี้ เนื่องจากมีข้อมูลการฝึกไม่มากนัก เราจึงส่ง function ว่างไป

ไม่จำเป็นต้องพูด บอทจะดีขึ้นเมื่อมีข้อมูลการฝึกอบรมมากขึ้น ในบทช่วยสอนนี้ เราใช้ตัวแยกประเภทเริ่มต้น ซึ่งปัจจุบันคือตัวแยกประเภท LogisticRegression จากไลบรารีตัวแยกประเภท talkify-natural โดยทั่วไปตัวแยกประเภทนี้ต้องการข้อมูลการฝึกอีกเล็กน้อยเพื่อเริ่มต้น แต่มีความแม่นยำมากกว่าตัวแยกประเภทอื่นในสภาวะส่วนใหญ่

เพิ่มทักษะ

เมื่อคุณได้ฝึกฝนบอทสำหรับบางหัวข้อแล้ว คุณจะต้องเพิ่มทักษะบางอย่าง ทักษะคือการกระทำที่บอทจะดำเนินการเมื่อจดจำหัวข้อได้ ดังนั้นหัวข้อและทักษะจึงแมปเป็น 1:1

หากต้องการเพิ่มทักษะ คุณต้องสร้างมันขึ้นมาก่อน ทักษะต้องมีสามสิ่ง ชื่อของทักษะที่เป็นเอกลักษณ์ของบอท ชื่อนี้ใช้เพื่อเชื่อมโยงทักษะในภายหลังภายในบริบท หัวข้อที่แมปและฟังก์ชันที่บอทจะเรียกใช้เพื่อดำเนินการทักษะ ฟังก์ชันนี้จะใช้พารามิเตอร์สี่ตัว ได้แก่: context, request, response, next พารามิเตอร์ context ใช้เพื่อจัดเก็บข้อมูลบริบทที่เป็นประโยชน์จากทักษะนั้น พารามิเตอร์ request ประกอบด้วยข้อมูลเกี่ยวกับคำขอ เช่นเดียวกับ response พารามิเตอร์ next คือฟังก์ชันที่คุณสามารถเรียกใช้เพื่อให้บอตทราบว่าคุณประมวลผลเสร็จแล้ว ทักษะมีลักษณะดังนี้:

 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 ) ;

หมายเหตุ: ไม่สามารถกำหนดชื่อของทักษะได้ อย่างไรก็ตาม โปรดทราบว่าการทำเช่นนี้หมายความว่าบอทจะดำเนินการทักษะนั้นเมื่อใดก็ตามที่ระดับความเชื่อมั่นเป็น 0 สำหรับการตอบสนองต่อคำถามที่กำหนด

เมื่อคุณได้กำหนดทักษะบางอย่างแล้ว คุณจะต้องเพิ่มทักษะเหล่านั้นลงในบอท เพิ่มทักษะให้กับบอทดังนี้:

 bot . addSkill ( howSkill ) ;
bot . addSkill ( helpSkill ) ;

แก้ไขข้อสงสัย

เมื่อเพิ่มแล้ว คุณสามารถขอให้บอทแก้ไขบางสิ่งบางอย่างได้แล้ว นี่คือที่ที่คุณกำลังสอบถามบอทด้วยประโยค และมันจะตอบกลับด้วยข้อความแบบอะซิงโครนัส ฟังก์ชันการแก้ไขจะใช้พารามิเตอร์สามตัว: contextId, text, callback contextId ช่วยให้บอทแก้ไขบริบทจากการสนทนาครั้งก่อนๆ text คือคำถามหรือส่วนหนึ่งของสตริงภาษาธรรมชาติที่บอทต้องตีความและตอบกลับ สุดท้ายนี้ callback คือฟังก์ชัน callback ที่บอทจะเรียกใช้ด้วย err, messages เพื่อระบุข้อผิดพลาด (ถ้ามี) และเป็นการตอบกลับข้อความ

 var resolved = function ( err , messages ) {
    if ( err ) return console . error ( err ) ;

    return console . log ( messages ) ;
} ;

bot . resolve ( 123 , 'Assistance required' , resolved ) ;

เรียกใช้เหมือนไฟล์โหนดธรรมดาและควรพิมพ์สิ่งต่อไปนี้ในคอนโซล

 [ { type: 'SingleLine',
    content: 'You asked: "Assistance required". I can tell you how I'm doing if you ask nicely.' } ]

ลองเปลี่ยน bot.resolve เป็นสิ่งนี้และสังเกตการเปลี่ยนแปลงในการตอบสนอง

 bot . resolve ( 456 , 'How's it going?' , resolved ) ;

ลองถามสองสิ่งพร้อมกัน เปลี่ยน bot.resolve อีกครั้งเป็น:

 bot . resolve ( 456 , 'How's it going? Assistance required please.' , resolved ) ;

เมื่อคุณรันโค้ด คุณควรได้รับข้อความตอบกลับสองข้อความ:

 [ { 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.' } ]

วิธีการแบบล่ามโซ่

ปัจจุบันวิธี train , addSkill และ resolve สามารถเชื่อมต่อกันได้ นั่นหมายความว่าคุณสามารถสร้างออบเจ็กต์ Bot และวิธีการแบบเรียงซ้อนได้ดังที่กล่าวไว้ด้านล่าง

	new Bot ( ) . train ( topic , sentence ) . addSkill ( skill ) . resolve ( ... . ) 

ตัวเลือกการกำหนดค่า

ร้านค้าบริบท

แกนหลักของบอทยังยอมรับการใช้งานทางเลือกสำหรับที่เก็บบริบทในตัว โปรดดูการจัดการบริบทสำหรับรายละเอียดเพิ่มเติม

ลักษณนาม

คุณยังสามารถจัดหาตัวแยกประเภทเวอร์ชันของคุณเองให้กับบอทได้ ตัวเลือกนี้ใช้เพื่อทำให้การทดสอบง่ายขึ้นเป็นหลัก อย่างไรก็ตาม ยังคงสามารถใช้ในการผลิตได้หากคุณมีตัวแยกประเภทในตัวเวอร์ชันที่ดีกว่า

ตัวแยกประเภทในตัวคือตัวแยกประเภท talkify-natural ตัวแยกประเภทนี้มีการใช้งานสองแบบ:

• LogisticRegressionClassifier
• BayesClassifier

LogisticRegressionClassifier คือตัวแยกประเภทเริ่มต้น หากคุณต้องการใช้ BayesClassifier จาก talkify-natural-classifier คุณสามารถทำสิ่งต่อไปนี้:

 var BayesClassifier = require ( 'talkify-natural-classifier' ) . BayesClassifier ;

var bot = new Bot ( { classifier : new BayesClassifier ( ) } ) ;

หากคุณต้องการใช้ Natural Language Processing Classifier ของ IBM Watson แทน คุณควรใช้ไลบรารี talkify-watson-classifier แทน โปรดดูคำแนะนำในหน้าพื้นที่เก็บข้อมูล Github สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับวิธีใช้ตัวแยกประเภทนั้น

หากคุณคิดว่าของคุณทำงานได้ดีขึ้น ตะโกนบอกฉันสิ! ฉันยินดีเป็นอย่างยิ่งที่ได้ทราบและอาจดำเนินการเพื่อนำไปปฏิบัติภายในโมดูลหลัก

กลยุทธ์การแก้ปัญหาทักษะ

เพื่อให้การนำกลยุทธ์การแก้ปัญหาทักษะไปใช้ด้วยตนเอง เพียงส่งคำจำกัดความฟังก์ชันในออบเจ็กต์การกำหนดค่าดังต่อไปนี้:

 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
} ) ;

แกนหลักของบอทจะสร้างอินสแตนซ์ของออบเจ็กต์กลยุทธ์การแก้ไขทักษะของคุณตั้งแต่เริ่มต้น และจะใช้เป็นอินสแตนซ์เดียวในการแก้ปัญหาทั้งหมด

กลยุทธ์การแก้ปัญหาหัวข้อ

หากต้องการจัดเตรียมการใช้ Topic Resolution Strategy ของคุณเอง เพียงส่งคำจำกัดความของฟังก์ชันในอ็อบเจ็กต์การกำหนดค่าดังนี้:

 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
} ) ;

แกนหลักของบอทจะสร้างอินสแตนซ์ใหม่ของกลยุทธ์การแก้ปัญหาหัวข้อของคุณทุกครั้งที่ได้รับการติดต่อไปยังวิธีการแก้ไขปัญหา

การขยายบอท

การจัดการบริบท

ตามค่าเริ่มต้น แกนหลักของบอทจะใช้ ContextStore เวอร์ชันในตัว หากคุณดูที่ lib/ContextStore.js คุณจะพบว่ามันเป็นการใช้งานที่ง่ายมาก โดยที่บริบทถูกจัดเก็บไว้ในแมปในหน่วยความจำแบบธรรมดา โดยมี contextId เป็นคีย์ และอ็อบเจ็กต์บริบทเป็นค่า แน่นอนว่าเมื่อคุณปรับใช้สิ่งนี้ ที่จัดเก็บบริบทในตัวจะมีข้อจำกัดอย่างมาก

การขยายที่เก็บบริบทนั้นง่ายมาก ภายในการกำหนดค่า คุณสามารถจัดเตรียมการใช้งานออบเจ็กต์ ContextStore ของคุณเองได้ รหัสต่อไปนี้มีการใช้งานที่ไม่สำคัญมากซึ่งเพียงแค่บันทึกค่าลงในคอนโซล

 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 } ) ;

ข้อมูลจำเพาะปัจจุบันสำหรับ ContextStore ต้องใช้ฟังก์ชัน 3 รายการ สิ่งเหล่านี้ put, get and remove ตราบใดที่มีการระบุวิธีการเหล่านี้ บอทจะไม่สนใจว่าค่าสำหรับฟิลด์ contextStore ใน config มาจากไหน

หากคุณต้องรันโค้ดนั้นด้วยการแก้ไขแบบสอบถาม คุณจะพบว่าฟังก์ชันการลบไม่เคยถูกเรียกใช้ งานนี้อยู่ในระหว่างดำเนินการ เนื่องจากขณะนี้ไม่จำกัดระยะเวลาในการจดจำบริบท

ลักษณนามที่กำหนดเอง

ตามที่กล่าวไว้ก่อนหน้านี้ ตัวแยกประเภทเริ่มต้นที่บอทใช้นั้นมาจากไลบรารี talkify-natural-classifier คุณมีอิสระที่จะเขียนตัวแยกประเภทของคุณเองและใช้ในแอปพลิเคชันของคุณ ในการดำเนินการนี้ คุณจะต้องขยายอินเทอร์เฟซตัวแยกประเภทที่กำหนดไว้ในไลบรารีตัวแยกประเภท talkify

เมื่อคุณขยายการใช้งานนั้นได้สำเร็จแล้ว คุณสามารถจัดหาตัวแยกประเภทของคุณให้กับบอทได้ดังนี้:

 var myClassifier = new MyAwesomeClassifier ( ) ;
var bot = new Bot ( { classifier : myClassifier } ) ;

ฉันอยากเห็นการใช้งานตัวแยกประเภท talkify ของคุณ หากคุณได้ขยายอินเทอร์เฟซและใช้งานตัวแยกประเภทของคุณสำเร็จแล้ว บอกฉันสิ! ฉันยินดีเป็นอย่างยิ่งที่ได้ทราบประสบการณ์ของคุณในการใช้ห้องสมุดนี้

ตั้งแต่เวอร์ชัน 2.1.0 คุณสามารถระบุตัวแยกประเภทหลายตัวสำหรับบอทของคุณได้ ดูเอกสารเกี่ยวกับลักษณนามสำหรับข้อมูลเพิ่มเติม

กลยุทธ์การแก้ปัญหาทักษะ

กลยุทธ์การแก้ปัญหาทักษะเป็นองค์ประกอบที่สามารถแสดงทักษะออกมาได้ โดยพิจารณาจากบริบทของการแก้ไข บริบทการแก้ปัญหาคือวัตถุที่ประกอบด้วยรายการหัวข้อและประโยคต้นฉบับ ซึ่งเป็นส่วนประกอบสำคัญที่จำเป็นในการแก้ไขทักษะ

 +-------------+
 |  Topic  | | |
 +---------+ | +----> +--------------+
 |-----------+ |      |              |
 +-------------+      |  Skill       |      +---------+
                      |  Resolution  +----> |  Skill  |
                      |  Strategy    |      +---------+
 +------------+       |              |
 |  Sentence  | +---> +--------------+
 +------------+

กลยุทธ์การแก้ปัญหาหัวข้อ

กลยุทธ์การแก้ไขหัวข้อช่วยให้คุณสามารถเสียบตรรกะที่กำหนดเองเพื่อแก้ไขหัวข้อตามข้อมูลการจัดหมวดหมู่ เมื่อเสียบกลยุทธ์การแก้ปัญหาหัวข้อแบบกำหนดเอง แกนหลักของบอทคาดหวังว่าจะส่งคำจำกัดความของฟังก์ชันเข้าไปแทนผลลัพธ์ของการดำเนินการฟังก์ชัน เนื่องจากออบเจ็กต์กลยุทธ์การแก้ปัญหาหัวข้อถูกสร้างขึ้นโดยใช้ new สำหรับทุกการเรียกเพื่อ resolve วิธีการ

กระบวนการแก้ไขหัวข้อแบ่งออกเป็นสองส่วน:

ขั้นตอนที่ 1

ขั้นตอนแรกของกระบวนการแก้ไขหัวข้อคือขั้นตอนการรวบรวม ที่นี่ แกนหลักของบอทจะส่งการจัดหมวดหมู่สำหรับชุดการจัดหมวดหมู่ทุกชุดที่ส่งคืนจากตัวแยกประเภทพร้อมกับบริบทที่จำเป็น แกนหลักของบอทยังส่งผ่านฟังก์ชันการโทรกลับซึ่งจำเป็นต้องเรียกใช้เพื่อให้แกนหลักของบอททราบว่าการเรียกใช้สำเร็จ

 +------------------+ +
|  Classification  | |
+------------------+ |
                     |        +-----------+
                     +-------->  Collect  |
                     |        +-----------+
       +-----------+ |
       |  Context  | |
       +-----------+ +

ขั้นตอนที่ 2

ขั้นตอนที่สองคือขั้นตอนการแก้ปัญหา ที่นี่ บอทคอร์คาดว่าจะส่งคืนรายการการจำแนกประเภท การแก้ปัญหาจะถูกเรียกหลังจากดำเนินการคอลเลกชันทั้งหมดเสร็จสิ้นแล้วเท่านั้น

 +-----------+     +---------+-+-+
|  Resolve  +---->+  Topic  | | |
+-----------+     +---------+ | |
                  |-----------+ |
                  +-------------+

ออบเจ็กต์กลยุทธ์การแก้ปัญหาหัวข้อต้องเปิดเผยสองวิธี:

• เก็บรวบรวม
• แก้ไข

วิธีการรวบรวมจะถูกเรียกทุกครั้งที่ตัวแยกประเภทส่งคืนการจัดประเภท มันถูกเรียกด้วย classification, context, callback ออบเจ็กต์ classification ประกอบด้วยการจัดหมวดหมู่ที่ส่งคืนจากตัวแยกประเภท (หรือชุดของตัวแยกประเภทหากใช้องค์ประชุม) วัตถุ context คือวัตถุที่มีบริบทคำขอ callback พารามิเตอร์สุดท้ายคือฟังก์ชันที่ต้องเรียกใช้เพื่อให้บอทคอร์ทราบว่าคุณได้รวบรวมพารามิเตอร์ที่ส่งผ่านเสร็จแล้ว

วิธีการแก้ไขจะถูกเรียกหนึ่งครั้งหลังจากบอตคอร์เสร็จสิ้นการเรียก collect กลยุทธ์การแก้ปัญหาหัวข้อของคุณ นี่คือการโทรครั้งสุดท้ายจากแกนหลักของบอท และมีวัตถุประสงค์เพื่อรวบรวมข้อมูลการแก้ไขหัวข้อ วิธี resolve ถูกเรียกพร้อมกับพารามิเตอร์ callback นี่คือฟังก์ชันการโทรกลับที่ต้องถูกเรียกโดยมี error, topics พารามิเตอร์ข้อผิดพลาดจะต้องถูกกำหนดให้เป็นออบเจ็กต์ข้อผิดพลาดในกรณีที่เกิดข้อผิดพลาดขณะแก้ไขหัวข้อ ในกรณีอื่น ๆ วัตถุนี้จะต้อง undefined พารามิเตอร์ topics ที่สองต้องเป็นอาร์เรย์ของหัวข้อที่ได้รับการแก้ปัญหาโดยกลยุทธ์การแก้ปัญหา

เอกสารอ้างอิง

• ลักษณนาม
• ทักษะ

มีส่วนร่วม

โปรดดูคู่มือการมีส่วนร่วมสำหรับรายละเอียดเพิ่มเติม