Unduh talkify - unduh kode sumber talkify

berbicara

Kerangka pengembangan aplikasi chatbot.

Penggunaan
- Pengaturan
- Tutorial Kode
  - Inisialisasi
  - Kereta
  - Tambahkan Keterampilan
  - Selesaikan pertanyaan
  - Metode yang dapat dirantai
- Opsi Konfigurasi
  - Penyimpanan Konteks
  - Penggolong
- Memperluas bot
  - Manajemen konteks
  - Pengklasifikasi Khusus
Dokumentasi Referensi
Berkontribusi

Penggunaan

Pengaturan

Pastikan Anda telah menginstal node dan npm. Saat ini, modul ini telah diuji terhadap versi node 0,12 dalam pipeline Travis CI.

Cukup jalankan perintah npm install untuk menginstal:

npm install --save talkify

Tutorial Kode

Inisialisasi

Memerlukan modul utama, tipe dan dependensi. Perintah berikut memuat semua yang Anda perlukan dari 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 ;

Setelah dependensi dimuat, Anda dapat menginisialisasi inti bot.

 const bot = new Bot ( ) ;

Konstruktor Bot() juga menerima parameter dalam bentuk objek konfigurasi. Di sini Anda dapat meneruskan nilai peralihan konfigurasi atau implementasi alternatif untuk hal-hal seperti ContextStore dan Classifier dll. Kami akan membahasnya nanti di bagian Opsi Konfigurasi.

Kereta

Setelah Bot diinisialisasi, hal pertama yang harus Anda lakukan adalah melatihnya. Untuk melatihnya satu dokumen pada satu waktu secara sinkron, Anda dapat menggunakan metode 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 ( ) { } ) ;

Kode di atas melatih bot untuk mengenali topik how_are_you ketika teksnya terlihat seperti how are you atau how are you doing serta how is it going tetapi untuk mengenali topik help ketika teksnya terlihat seperti how can you help atau i need some help serta how can you assist me . Beginilah cara Anda melatih bot.

Metode trainAll menerima array objek TrainingDocument serta fungsi panggilan balik. Konstruktor objek TrainingDocument menerima dua parameter. Ini adalah topicName dan trainingData . Parameter topicName adalah nama topik yang ingin Anda latih trainingData dan trainingData adalah kalimat yang Anda masukkan ke bot sebagai data pelatihannya. topicName nantinya akan dipetakan ke keterampilan sebenarnya yang dapat ditanggapi oleh bot.

Callback untuk metode trainAll adalah fungsi yang dapat dipanggil oleh bot ketika pelatihan selesai. Jika Anda memiliki terlalu banyak data pelatihan, Anda harus menerapkannya dengan benar. Dalam contoh ini, karena tidak banyak data pelatihan, kami meneruskan function kosong.

Tentu saja, bot menjadi lebih baik dengan lebih banyak data pelatihan. Dalam tutorial ini kita menggunakan pengklasifikasi default, yang saat ini merupakan pengklasifikasi LogisticRegression dari pustaka talkify-natural-classifier. Pengklasifikasi ini biasanya memerlukan lebih banyak data pelatihan untuk memulai, tetapi lebih akurat dibandingkan pengklasifikasi lainnya di sebagian besar kondisi.

Tambahkan Keterampilan

Setelah Anda melatih bot untuk beberapa topik, Anda perlu menambahkan beberapa keterampilan. Keterampilan adalah tindakan yang akan dilakukan bot saat mengenali suatu topik. Jadi topik dan keterampilan dipetakan ke 1:1.

Untuk menambah keterampilan, Anda perlu membuatnya terlebih dahulu. Sebuah keterampilan membutuhkan tiga hal. Nama keterampilan yang unik untuk bot. Nama tersebut digunakan untuk menghubungkan keterampilan di kemudian hari dalam konteksnya. Topik yang dipetakan dan fungsi yang akan dipanggil bot untuk menjalankan keterampilan. Fungsi ini akan mengambil empat parameter yaitu: context, request, response, next . Parameter context digunakan untuk menyimpan informasi kontekstual yang berguna dari keterampilan itu. Parameter request berisi informasi tentang permintaan, sama untuk response . Parameter next adalah fungsi yang dapat Anda panggil untuk memberi tahu bot bahwa Anda sudah selesai memproses. Berikut adalah tampilan suatu keterampilan:

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

Catatan: Nama suatu keterampilan tidak dapat ditentukan. Namun, perlu diketahui bahwa hal ini berarti bot akan mengeksekusi keterampilan tersebut setiap kali tingkat kepercayaannya 0 untuk merespons kueri yang diberikan.

Setelah Anda menentukan beberapa keterampilan, Anda perlu menambahkannya ke bot. Tambahkan keterampilan ke bot seperti ini:

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

Selesaikan pertanyaan

Setelah ditambahkan, kini Anda dapat meminta bot untuk menyelesaikan sesuatu. Di sinilah Anda menanyakan bot dengan sebuah kalimat dan bot akan merespons dengan pesan secara asinkron. Fungsi penyelesaian mengambil tiga parameter: contextId, text, callback . contextId membantu bot menyelesaikan konteks dari percakapan sebelumnya. text adalah pertanyaan atau bagian dari string bahasa alami yang perlu ditafsirkan dan ditanggapi oleh bot. Terakhir, callback adalah fungsi panggilan balik yang akan dipanggil bot dengan err, messages untuk menunjukkan kesalahan (jika ada) dan pesan balasannya.

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

    return console . log ( messages ) ;
} ;

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

Jalankan seperti file simpul sederhana dan itu akan mencetak yang berikut ini di konsol.

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

Coba ubah bot.resolve menjadi ini dan perhatikan perubahan responsnya.

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

Mari kita tanyakan dua hal sekaligus. Ubah bot.resolve lagi menjadi:

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

Saat Anda menjalankan kode, Anda akan mendapatkan dua pesan kembali:

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

Metode yang dapat dirantai

Saat ini metode train , addSkill dan resolve dapat dirantai. Itu berarti Anda dapat membuat objek Bot dan metode berjenjang seperti yang disebutkan di bawah ini.

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

Opsi Konfigurasi

Penyimpanan Konteks

Inti bot juga menerima implementasi alternatif untuk penyimpanan konteks bawaan. Silakan lihat Manajemen konteks untuk lebih jelasnya.

Penggolong

Anda juga dapat menyediakan pengklasifikasi versi Anda sendiri ke bot. Opsi ini terutama digunakan untuk mempermudah pengujian, namun masih dapat digunakan dalam produksi jika Anda memiliki versi pengklasifikasi bawaan yang lebih baik.

Pengklasifikasi bawaan adalah pengklasifikasi talkify-natural. Pengklasifikasi ini menyediakan dua implementasi:

LogisticRegressionClassifier
BayesClassifier

LogisticRegressionClassifier adalah pengklasifikasi default. Jika Anda lebih suka menerapkan BayesClassifier dari talkify-natural-classifier , Anda dapat melakukan hal berikut:

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

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

Jika Anda lebih suka menggunakan Pengklasifikasi Pemrosesan Bahasa Alami IBM Watson, Anda harus menggunakan perpustakaan pengklasifikasi talkify-watson sebagai gantinya. Silakan lihat panduan di halaman repositori Github untuk detail lebih lanjut tentang cara menggunakan pengklasifikasi tersebut.

Jika menurut Anda milik Anda bekerja lebih baik, beri tahu saya! Saya akan senang mengetahui dan mungkin berupaya menerapkannya dalam modul inti.

Strategi resolusi keterampilan

Untuk menyediakan implementasi Strategi Resolusi Keterampilan Anda sendiri, cukup berikan definisi fungsi di objek konfigurasi sebagai berikut:

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

Inti bot akan membuat instance objek strategi resolusi keahlian Anda di init dan akan menggunakannya sebagai instance tunggal di semua resolusi.

Strategi penyelesaian topik

Untuk menyediakan implementasi Strategi Resolusi Topik Anda sendiri, cukup berikan definisi fungsi di objek konfigurasi sebagai berikut:

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

Inti bot akan membuat instance baru dari strategi penyelesaian topik Anda untuk setiap panggilan yang diterima ke dalam metode penyelesaian.

Memperluas bot

Manajemen konteks

Secara default, inti bot menggunakan ContextStore versi bawaannya. Jika Anda melihat lib/ContextStore.js, Anda akan menemukan bahwa ini adalah implementasi yang sangat sederhana di mana konteks disimpan dalam peta dalam memori sederhana dengan contextId sebagai kuncinya dan objek konteks sebagai nilainya. Tentu saja ketika Anda menerapkan ini, penyimpanan konteks bawaan akan sangat terbatas.

Memperluas penyimpanan konteks sangatlah mudah. Di dalam konfigurasi, Anda dapat menyediakan implementasi Anda sendiri untuk objek ContextStore. Kode berikut menyediakan implementasi yang sangat sepele yang hanya mencatat nilai ke konsol.

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

Spesifikasi ContextStore saat ini memerlukan tiga fungsi untuk diimplementasikan. Ini put, get and remove . Selama metode ini disediakan, bot tidak peduli dari mana nilai kolom contextStore di konfigurasi berasal.

Jika Anda menjalankan kode tersebut dengan beberapa penyelesaian kueri, Anda akan menemukan bahwa fungsi hapus tidak pernah dipanggil. Ini masih dalam proses karena saat ini tidak ada batasan berapa lama suatu konteks harus diingat.

Pengklasifikasi Khusus

Seperti disebutkan sebelumnya, pengklasifikasi default yang digunakan bot berasal dari perpustakaan talkify-natural-classifier. Anda bebas menulis pengklasifikasi Anda sendiri dan menggunakannya dalam aplikasi Anda. Untuk melakukan ini, Anda perlu memperluas antarmuka pengklasifikasi yang ditentukan di perpustakaan pengklasifikasi talkify.

Setelah Anda berhasil memperluas implementasi tersebut, Anda dapat menyediakan pengklasifikasi Anda ke bot seperti:

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

Saya ingin melihat penerapan Anda terhadap pengklasifikasi talkify. Jika Anda telah memperluas antarmuka dan berhasil mengimplementasikan pengklasifikasi Anda, beri tahu saya! Saya akan senang mengetahui pengalaman Anda menggunakan perpustakaan ini.

Sejak versi 2.1.0, Anda dapat menentukan beberapa pengklasifikasi untuk bot Anda. Lihat dokumen tentang pengklasifikasi untuk info lebih lanjut.

Strategi Resolusi Keterampilan

Strategi resolusi keterampilan adalah komponen yang mampu menghasilkan suatu keterampilan, dengan konteks resolusi. Konteks resolusi adalah objek yang terdiri dari daftar topik dan kalimat asli, bahan penting yang diperlukan untuk menyelesaikan suatu keterampilan.

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

Strategi Penyelesaian Topik

Strategi resolusi topik memungkinkan Anda memasukkan logika kustom untuk menyelesaikan topik, berdasarkan data klasifikasi. Saat memasukkan strategi resolusi topik khusus, inti bot mengharapkan definisi fungsi diteruskan, bukan hasil eksekusi fungsi. Hal ini karena objek strategi penyelesaian topik dibuat menggunakan metode resolve new untuk setiap panggilan.

Proses penyelesaian topik bekerja dalam dua bagian:

Langkah 1

Tahap pertama dari proses penyelesaian topik adalah tahap pengumpulan. Di sini, inti bot mengirimkan klasifikasi untuk setiap kumpulan klasifikasi yang dikembalikan dari pengklasifikasi beserta konteks yang diperlukan. Inti bot juga meneruskan fungsi panggilan balik yang perlu dipanggil agar inti bot mengetahui bahwa pemanggilan berhasil.

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

Langkah 2

Tahap kedua adalah tahap resolusi. Di sini, inti bot mengharapkan daftar klasifikasi dikembalikan. Resolusi dipanggil hanya setelah semua koleksi selesai dieksekusi.

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

Objek strategi resolusi topik harus memaparkan dua metode:

mengumpulkan
menyelesaikan

Metode pengumpulan dipanggil setiap kali pengklasifikasi mengembalikan klasifikasi. Itu disebut dengan classification, context, callback . Objek classification berisi klasifikasi yang dikembalikan dari pengklasifikasi (atau kumpulan pengklasifikasi jika menggunakan kuorum). Objek context adalah objek yang berisi konteks permintaan. callback parameter terakhir adalah fungsi yang harus dipanggil agar inti bot mengetahui bahwa Anda telah selesai mengumpulkan parameter yang diteruskan.

Metode penyelesaian dipanggil satu kali setelah inti bot selesai memanggil collect strategi penyelesaian topik Anda. Ini adalah panggilan terakhir dari inti bot dan dimaksudkan untuk mengumpulkan informasi penyelesaian topik. Metode resolve dipanggil dengan parameter callback . Ini adalah fungsi panggilan balik yang harus dipanggil dengan dua parameter error, topics . Parameter kesalahan harus didefinisikan sebagai objek kesalahan jika terjadi kesalahan saat menyelesaikan topik. Dalam kasus lain, objek ini harus undefined . Parameter topics kedua harus berupa rangkaian topik yang diselesaikan dengan strategi resolusi.