Membangun Chatbot Sederhana Dari Awal dengan Python

Saya yakin Anda pernah mendengar mengenai Duolingo: program pembelajaran bahasa yang terkenal, yang mempraktikkan bahasa baru. Ini cukup terkenal karena gaya edukasi bahasa asing yang inovatif. Konsepnya sederhana: lima sampai sepuluh menit training interaktif satu hari cukup untuk belajar bahasa.

Tetapi, walau Duolingo memungkinkan orang mempelajari bahasa baru, beberapa praktisinya mempunyai kekhawatiran. Beberapa orang merasa kehilangan peluang untuk mempelajari ketrampilan percakapan yang berharga karena mereka belajar sendiri. Beberapa orang khawatir dipasangkan dengan pembelajar bahasa lain karena takut malu. Ini ternyata menjadi hambatan yang signifikan dalam rencana Duolingo.

Jadi, tim mereka memecahkan masalah ini dengan membuat chatbot asli di dalam aplikasinya untuk membantu pengguna mempelajari keterampilan percakapan dan mempraktikkan apa yang telah mereka pelajari.

Karena bot dirancang sebagai percakapan dan ramah, pelajar Duolingo dapat berlatih percakapan kapan saja sepanjang hari, menggunakan karakter pilihan mereka, hingga mereka merasa cukup berani untuk mempraktikkan bahasa baru mereka dengan pembicara lain. Ini memecahkan masalah utama konsumen dan menjadikan belajar melalui aplikasi jauh lebih menyenangkan.

Jadi apa itu chatbot?

Chatbot adalah perangkat lunak bertenaga kecerdasan buatan di perangkat (Siri, Alexa, Google Assistant, dll.), Aplikasi, situs web, atau jaringan lainnya. Ini mengukur kebutuhan konsumen dan kemudian membantu mereka dalam melakukan tugas tertentu seperti transaksi komersial, pemesanan hotel, pengiriman formulir, dll. Saat ini hampir setiap perusahaan memiliki chatbot yang digunakan untuk terlibat dengan pengguna. Beberapa cara perusahaan menggunakan chatbots adalah :

• Untuk menyampaikan informasi penerbangan
• Untuk menghubungkan pelanggan dan keuangan mereka
• Sebagai dukungan pelanggan

Kemungkinannya (hampir) tidak terbatas.

Sejarah chatbot dimulai pada tahun 1966 ketika sebuah program komputer bernama ELIZA ditemukan oleh Weizenbaum. Itu meniru bahasa psikoterapis hanya dari 200 baris kode. Anda masih bisa berkomunikasi dengannya di sini: Eliza.

Bagaimana cara kerja Chatbot?

Secara luas ada dua varian chatbots: Berbasis Aturan dan Belajar Mandiri.

1. Dalam pendekatan berbasis Aturan, bot menjawab pertanyaan berdasarkan beberapa aturan, yang menjadi dasar pelatihannya. Aturan yang ditetapkan bisa sangat sederhana hingga sangat kompleks. Bot dapat menangani kueri sederhana tetapi gagal mengelola kueri yang rumit.
2. Bot belajar mandiri adalah yang menggunakan beberapa pendekatan berbasis Pembelajaran Mesin dan lebih efisien daripada bot berbasis aturan. Bot ini dapat terdiri dari dua jenis lebih lanjut: Berbasis Pengambilan atau Generatif.

i) Dalam model berbasis pengambilan, chatbot menggunakan beberapa heuristik untuk memilih respons dari pustaka respons yang telah ditentukan sebelumnya. Chatbot menggunakan pesan dan konteks percakapan untuk memilih respons terbaik dari daftar pesan bot yang telah ditentukan sebelumnya. Konteksnya dapat mencakup posisi saat ini di pohon dialog, semua pesan sebelumnya dalam percakapan, variabel yang disimpan sebelumnya (mis., nama pengguna). Heuristik untuk memilih respons dapat direkayasa dengan berbagai cara, mulai dari logika bersyarat if-else berbasis aturan hingga pengklasifikasi pembelajaran mesin.

ii) Bot generatif dapat menghasilkan jawaban dan tidak selalu membalas dengan salah satu jawaban dari sekumpulan jawaban. Ini membuat mereka lebih cerdas karena mengambil kata demi kata dari kueri dan menghasilkan jawaban.

Pada artikel ini kita akan membuat chatbot berbasis pengambilan sederhana berdasarkan pustaka NLTK dengan python.

Membuat Bot

Prasyarat

Pengetahuan langsung tentang perpustakaan scikit dan NLTK diasumsikan. Namun, jika Anda baru mengenal NLP, Anda masih dapat membaca artikelnya dan merujuk kembali ke sumber daya.

NLP

Bidang studi yang berfokus pada interaksi antara bahasa manusia dan komputer disebut Natural Language Processing, atau disingkat NLP. Itu berada di persimpangan ilmu komputer, kecerdasan buatan, dan linguistik komputasi [Wikipedia]. NLP adalah cara komputer untuk menganalisis, memahami, dan memperoleh makna dari bahasa manusia dengan cara yang cerdas dan berguna. Dengan memanfaatkan NLP, pengembang dapat mengatur dan menyusun pengetahuan untuk melakukan tugas-tugas seperti peringkasan otomatis, terjemahan, pengenalan entitas bernama, ekstraksi hubungan, analisis sentimen, pengenalan ucapan, dan segmentasi topik.

NLTK: Pengantar Singkat

NLTK (Natural Language Toolkit) adalah platform terdepan untuk membangun program Python agar bekerja dengan data bahasa manusia. Ini menyediakan antarmuka yang mudah digunakan untuk lebih dari 50 kumpulan dan sumber daya leksikal seperti WordNet, bersama dengan rangkaian pustaka pemrosesan teks untuk klasifikasi, tokenisasi, stemming, penandaan, parsing, dan penalaran semantik, pembungkus untuk pustaka NLP berkekuatan industri.

NLTK telah disebut sebagai "alat luar biasa untuk mengajar dan bekerja dalam komputasi linguistik menggunakan Python" dan "perpustakaan luar biasa untuk bermain dengan bahasa alami".

Pemrosesan Bahasa Alami dengan Python memberikan pengantar praktis untuk pemrograman untuk pemrosesan bahasa. Saya sangat merekomendasikan buku ini kepada orang-orang yang memulai NLP dengan Python.

Mengunduh dan menginstal NLTK

1. Instal NLTK: jalankan pip install nltk
2. Uji instalasi: jalankan python lalu ketik import nltk

Untuk instruksi khusus platform, baca di sini.

Menginstal Paket NLTK

Impor NLTK dan jalankan nltk.download(). Ini akan membuka pengunduh NLTK dari mana Anda dapat memilih kumpulan dan model untuk diunduh. Anda juga dapat mengunduh semua paket sekaligus.

Teks Pre-Processing dengan NLTK

Masalah utama dengan data teks adalah semuanya dalam format teks (string). Namun, algoritma pembelajaran mesin memerlukan semacam vektor fitur numerik untuk melakukan tugas tersebut. Jadi sebelum kita mulai dengan proyek NLP apa pun, kita perlu memprosesnya terlebih dahulu agar ideal untuk bekerja. Pre-Processing teks dasar meliputi:

• Mengubah seluruh teks menjadi huruf besar atau kecil sehingga algoritme tidak memperlakukan kata yang sama dalam kasus berbeda sebagai berbeda
• Tokenisasi: Tokenisasi hanyalah istilah yang digunakan untuk menggambarkan proses mengubah string teks normal menjadi daftar token, yaitu kata-kata yang kita inginkan. Tokenizer kalimat dapat digunakan untuk menemukan daftar kalimat, dan Tokenizer kata dapat digunakan untuk menemukan daftar kata dalam string.

Paket data NLTK mencakup tokenizer Punkt terlatih untuk bahasa Inggris.

• Menghapus Kebisingan, yaitu segala sesuatu yang tidak ada dalam angka atau huruf standar.
• Menghapus kata-kata Hentikan. Kadang-kadang, beberapa kata yang sangat umum yang tampaknya tidak banyak berguna dalam membantu memilih dokumen yang cocok dengan kebutuhan pengguna dikecualikan dari kosa kata seluruhnya. Kata-kata ini disebut kata berhenti.
• Stemming: Stemming adalah proses mengurangi kata-kata yang diinfleksikan (atau terkadang diturunkan) menjadi bentuk batang, dasar, atau akarnya - umumnya bentuk kata tertulis. Misalnya, jika kita membendung kata-kata berikut: "Batang", "Mengakar", "Mengakar", "dan Stemtisasi", hasilnya akan menjadi satu kata, "batang".
• Lemmatisasi: Varian kecil dari stemming adalah lemmatisasi. Perbedaan utama antara keduanya adalah bahwa stemming seringkali dapat membuat kata-kata yang tidak ada, sedangkan lemma adalah kata-kata yang sebenarnya. Jadi, kata dasar Anda, yang berarti kata yang Anda dapatkan, bukanlah sesuatu yang dapat Anda cari di kamus, tetapi Anda dapat mencari lemma. Contoh Lemmatisasi adalah bahwa "lari" adalah bentuk dasar untuk kata-kata seperti "lari" atau "lari" atau kata "lebih baik" dan "baik" berada dalam lemma yang sama, sehingga dianggap sama.

Tas Kata-kata

Setelah fase preprocessing awal, kita perlu mengubah teks menjadi vektor (atau larik) angka yang bermakna. Bag-of-words adalah representasi teks yang menggambarkan kemunculan kata-kata dalam dokumen. Ini melibatkan dua hal:

• Sebuah kosakata kata-kata yang dikenal.
• Sebuah ukuran kehadiran kata-kata yang dikenal.

Mengapa ini disebut "tas" kata-kata? Itu karena setiap informasi tentang urutan atau struktur kata dalam dokumen dibuang, dan model hanya memperhatikan apakah kata yang dikenal muncul dalam dokumen, bukan di mana kata itu muncul dalam dokumen.

Intuisi di balik Bag of Words adalah bahwa dokumen akan serupa jika memiliki konten yang identik. Selain itu, kita dapat mempelajari sesuatu tentang arti dokumen dari isinya saja.

Misalnya, jika kamus kita berisi kata-kata {Belajar, is, the, not, great}, dan kita ingin memvektor teks "Belajar itu hebat", kita akan memiliki vektor berikut: (1, 1, 0, 0, 1).

Pendekatan TF-IDF

Masalah dengan pendekatan Bag of Words adalah kata-kata yang sangat sering mulai mendominasi dalam dokumen (misalnya, skor yang lebih besar) tetapi mungkin tidak mengandung banyak "konten informasi". Juga, ini akan memberi bobot lebih pada dokumen yang lebih panjang daripada dokumen yang lebih pendek.

Salah satu pendekatannya adalah mengubah skala frekuensi kata berdasarkan seberapa sering kata tersebut muncul di semua dokumen sehingga skor untuk kata yang sering muncul seperti “the” yang juga sering muncul di semua dokumen akan dihukum. Pendekatan penilaian ini disebut Term Frequency-Inverse Document Frequency, atau singkatnya TF-IDF, di mana:

Term Frequency: adalah penilaian frekuensi kata dalam dokumen saat ini.

TF = (Number of times term t appears in a document)/(Number of terms in the document)

Frekuensi Dokumen Terbalik: adalah penilaian seberapa jarang kata tersebut ada di seluruh dokumen.

IDF = 1+log(N/n), where, N is the number of documents and n is the number of documents a term t has appeared in.

Bobot Tf-IDF merupakan bobot yang sering digunakan dalam information retrieval dan text mining. Bobot ini merupakan ukuran statistik yang digunakan untuk mengevaluasi seberapa penting sebuah kata bagi sebuah dokumen dalam kumpulan atau korpus.

Contoh:

Pertimbangkan sebuah dokumen yang berisi 100 kata di mana kata 'telepon' muncul 5 kali. Istilah frekuensi (yaitu, tf) untuk telepon kemudian (5/100) = 0,05. Sekarang, anggaplah kita memiliki 10 juta dokumen dan kata telepon muncul di seribu dokumen ini. Kemudian, frekuensi dokumen terbalik (yaitu, IDF) dihitung sebagai log(10.000.000 / 1.000) = 4. Dengan demikian, bobot Tf-IDF adalah produk dari kuantitas berikut: 0,05 * 4 = 0,20. Tf-IDF dapat diimplementasikan dalam scikit belajar sebagai: dari sklearn.feature_extraction.text impor TfidfVectorizer

Kesamaan Cosinus

TF-IDF adalah transformasi yang diterapkan pada teks untuk mendapatkan dua vektor bernilai riil dalam ruang vektor. Kita kemudian dapat memperoleh kesamaan Cosinus dari setiap pasangan vektor dengan mengambil produk titiknya dan membaginya dengan produk dari normanya. Itu menghasilkan cosinus sudut antara vektor. Kesamaan kosinus adalah ukuran kesamaan antara dua vektor bukan nol. Dengan menggunakan rumus ini, kita dapat mengetahui kesamaan antara dua dokumen d1 dan d2.

Cosine Similarity (d1, d2) =  Dot product(d1, d2) / ||d1|| * ||d2||

Di mana d1,d2 adalah dua vektor bukan nol.

Mengimpor perpustakaan yang diperlukan

import nltk
import numpy as np
import random
import string # to process standard python strings

Korpus

Sebagai contoh kami, kami akan menggunakan halaman Wikipedia untuk chatbots sebagai korpus kami. Salin konten dari halaman dan letakkan di file teks bernama 'chatbot.txt.' Namun, Anda dapat menggunakan corpus pilihan Anda.

Membaca dalam data

Kami akan membaca di file corpus.txt dan mengubah seluruh korpus menjadi daftar kalimat dan daftar kata untuk diproses lebih lanjut.

f=open('chatbot.txt','r',errors = 'ignore')
raw=f.read()
raw=raw.lower()# converts to lowercase
nltk.download('punkt') # first-time use only
nltk.download('wordnet') # first-time use only
sent_tokens = nltk.sent_tokenize(raw)# converts to list of sentences 
word_tokens = nltk.word_tokenize(raw)# converts to list of words

Mari lihat contoh sent_token dan word_token

sent_tokens[:2]
['a chatbot (also known as a talkbot, chatterbot, bot, im bot, interactive agent, or artificial conversational entity) is a computer program or an artificial intelligence which conducts a conversation via auditory or textual methods.',
 'such programs are often designed to convincingly simulate how a human would behave as a conversational partner, thereby passing the turing test.']
word_tokens[:2]
['a', 'chatbot', '(', 'also', 'known']

Pra-pemrosesan teks mentah

Kami sekarang akan mendefinisikan fungsi yang disebut LemTokens yang akan mengambil token input dan mengembalikan token yang dinormalisasi.

lemmer = nltk.stem.WordNetLemmatizer()
#WordNet is a semantically-oriented dictionary of English included in NLTK.
def LemTokens(tokens):
    return [lemmer.lemmatize(token) for token in tokens]
remove_punct_dict = dict((ord(punct), None) for punct in string.punctuation)
def LemNormalize(text):
    return 
LemTokens(nltk.word_tokenize(text.lower().translate(remove_punct_dict)))

Pencocokan kata kunci

Selanjutnya, kita akan mendefinisikan fungsi untuk sapaan oleh bot, yaitu, jika input pengguna adalah sapaan, bot akan mengembalikan respons sapaan. ELIZA menggunakan pencocokan kata kunci sederhana untuk sapaan. Kami akan menggunakan konsep yang sama di sini.

GREETING_INPUTS = ("hello", "hi", "greetings", "sup", "what's up","hey",)

GREETING_RESPONSES = ["hi", "hey", "*nods*", "hi there", "hello", "I am glad! You are talking to me"]

def greeting(sentence):
 
    for word in sentence.split():
        if word.lower() in GREETING_INPUTS:
            return random.choice(GREETING_RESPONSES)

Menghasilkan Respons

Untuk menghasilkan respons dari bot kami untuk pertanyaan masukan, konsep kesamaan dokumen akan digunakan. Jadi kita mulai dengan mengimpor modul yang diperlukan.

• Dari pustaka scikit learn, impor vektorizer TFidf untuk mengonversi kumpulan dokumen mentah menjadi matriks fitur TF-IDF.

  from sklearn.feature_extraction.text import TfidfVectorizer

• Juga, impor modul kesamaan cosinus dari perpustakaan scikit learn

  from sklearn.metrics.pairwise import cosine_similarity

Ini akan digunakan untuk menemukan kesamaan antara kata-kata yang dimasukkan oleh pengguna dan kata-kata dalam korpus. Ini adalah implementasi chatbot yang paling sederhana.

Kami mendefinisikan respons fungsi yang mencari ucapan pengguna untuk satu atau lebih kata kunci umum dan mengembalikan salah satu dari beberapa kemungkinan respons. Jika tidak menemukan input yang cocok dengan salah satu kata kunci, ia mengembalikan respons: “Maaf! Aku tidak memahami maksudmu."

def response(user_response):
    robo_response=''
    sent_tokens.append(user_response)    
TfidfVec = TfidfVectorizer(tokenizer=LemNormalize, 
stop_words='english')
    tfidf = TfidfVec.fit_transform(sent_tokens)
    vals = cosine_similarity(tfidf[-1], tfidf)
    idx=vals.argsort()[0][-2]
    flat = vals.flatten()
    flat.sort()
    req_tfidf = flat[-2]    
    if(req_tfidf==0):
        robo_response=robo_response+"I am sorry! I don't understand you"
        return robo_response
    else:
        robo_response = robo_response+sent_tokens[idx]
        return robo_response

Akhirnya, kami akan memberi makan baris yang kami ingin bot kami katakan saat memulai dan mengakhiri percakapan, tergantung pada input pengguna.

flag=True
print("ROBO: My name is Robo. I will answer your queries about 
Chatbots. If you want to exit, type Bye!")
while(flag==True):
    user_response = input()
    user_response=user_response.lower()
    if(user_response!='bye'):
        if(user_response=='thanks' or user_response=='thank you' ):
            flag=False
            print("ROBO: You are welcome..")
        else:
            if(greeting(user_response)!=None):
                print("ROBO: "+greeting(user_response))
            else:
                print("ROBO: ",end="")
                print(response(user_response))
                sent_tokens.remove(user_response)
    else:
        flag=False
        print("ROBO: Bye! take care..")

Jadi cukup banyak. Kami telah membuat kode chatbot pertama kami di NLTK. Sekarang, mari kita lihat bagaimana ia berinteraksi dengan manusia:

Ini tidak terlalu buruk. Meskipun chatbot tidak dapat memberikan jawaban yang memuaskan untuk beberapa pertanyaan, namun berhasil dengan baik pada pertanyaan lainnya.

Kesimpulan

Meskipun ini adalah bot yang sangat sederhana dengan keterampilan kognitif yang hampir tidak ada, ini adalah cara yang baik untuk masuk ke NLP dan mengetahui tentang chatbot. Namun, 'ROBO' merespons masukan pengguna. Itu tidak akan membodohi teman Anda, dan untuk sistem produksi, Anda akan ingin mempertimbangkan salah satu platform atau kerangka kerja bot yang ada, tetapi contoh ini akan membantu Anda memikirkan desain dan tantangan dalam membuat chatbot. Internet dibanjiri sumber daya, dan setelah membaca artikel ini, saya yakin Anda ingin membuat chatbot sendiri. Selamat mengutak-atik!

Terima kasih, Semoga Bermanfaat!

---

Artikel Terkait Lainnya :

• Dari Teori Ke Praktek dengan Bayesian Neural Network, Menggunakan Python
• Cara Mengembangkan API Menggunakan FastAPI Pada Python
• Inilah Bagaimana Cara Bootstrap 4 Grid Bekerja
• Buat Bot Telegram Sederhana Menggunakan Python Untuk Pemula
• Belajar Membuat Fungsi Di Pemrograman Python

Share this post