1

Pengumuman Penting dari Jo-Pink

Halo The Next Digital Talents!

Modul Artificial Intelligence ini memang

sengaja Jo-Pink kasih full pack theory &
application dengan materi yang ‘rich’
banget.

Mengapa?
Supaya bisa tetap dipelajari setelah lulus dari program Data
Science & Artificial Intelligence Startup Campus!

Tapi ini banyak banget, gimana belajarnya?

Teman-teman bisa fokus mempelajari learning video sambil
membaca modul bagian use case atau aplikasinya ya.

Kalau ada yang tidak dipahami di learning

video, modul ini akan berperan jadi
‘ensiklopedia’ untuk mengusut tuntas
kebingunganmu.

Selamat belajar!
2
 Daftar Isi
A. Apa itu Natural Language? (4)
B. Apa itu Natural Language Processing? (5)
C. Aplikasi NLP (6)
D. Istilah dalam NLP (6)
E. Apa itu Spacy? (6)
F. Apa itu NLTK? (8)
G. Spacy VS NLTK (10)
H. Konsep dan Teori NLP (11)
a. Konsep dasar Spacy (11)
b. Konsep dasar Tokenization (14)
c. Konsep dasar Stemming (19)
d. Konsep dasar Lemmatization (22)
e. Konsep dasar Stop Words (24)
f. Konsep dasar Phrase Matching (26)
g. Konsep dasar Part-of-Speech Tagging (POS Tagging) (33)
h. Konsep dasar Named Entity Recognition (NER) (39)
i. Konsep dasar Sentence Segmentation (45)
I. Aplikasi NLP (46)
a. Text Classification (46)
i. Studi Kasus : Pengkategorian sebuah teks Apakah Teks tersebut adalah Spam atau Bukan
(49)
b. Sentiment Analysis (56)
i. Studi Kasus : Review Aplikasi Pokemon Go pada Google Play Store - Part 1 (60)
ii. Studi Kasus : Review Aplikasi Pokemon Go pada Google Play Store - Part 2 (68)
c. Topic Modeling (72)
i. Studi Kasus : Penggolongan Topik Untuk Data BBC News dengan Model LDA (75)
ii. Studi Kasus : Penggolongan Topik Untuk Data BBC News dengan Model NMF (82)
d. Naive Bayes Theorem (86)
i. Studi Kasus : Melakukan Klasifikasi Data Sentimen dengan Naive Bayes (94)

3
 Daftar Isi
J. Deep Learning untuk NLP (101)
a. Recurrent Neural Network (102)
b. Long Short-Term Memory (103)
c. Studi Kasus : Membuat Text Generator dengan Neural Networks dan LSTM (109)
K. Advance NLP : Transformers (142)
a. Model Encoder (BERT) (146)
i. Studi Kasus : BERT untuk Topic Modeling (147)
b. Model Decoder (GPT) (152)
i. Studi Kasus : GPT untuk Text Generation (154)
c. Model Encoder - Decoder : Sequence-to-Sequence (BART) (157)
i. Studi Kasus : BART untuk Text Summarization (158)
L. Intermezzo : Aplikasi dari NLP (161)
M. Kesimpulan (162)
N. Exercise (163)

4
Apa itu Natural Language?
Manusia pada umumnya dikenal sebagai makhluk sosial. Arti dari makhluk sosial ini adalah
kemampuan makhluk hidup tersebut untuk dapat bersosialisasi dengan sesamanya manusia, dapat
berinteraksi dan saling mendukung satu sama lain melalui sebuah hubungan timbal balik. Sebagai
sebuah makhluk sosial, sangat sulit bagi seorang manusia untuk dapat hidup sendirian. Selain
sebuah makhluk sosial, manusia juga dikenal sebagai makhluk individu. Makhluk individu ini
berarti manusia tersebut memiliki hak atas dirinya untuk dapat menyesuaikan diri dengan
lingkungan yang ada di sekitarnya.
Tanpa disadari, manusia merupakan makhluk individu dan makhluk sosial sekaligus.
terkadang manusia dapat menjalani kehidupannya sendiri sebagai makhluk individu, namun pada
akhirnya manusia tersebut akan menjalani hubungan sebagai makhluk sosial dengan orang lain.
Lantas, apa ciri khas dari makhluk sosial ini?
Dari semua ciri khas yang mungkin dapat digambarkan, ciri utama yang menggambarkan
manusia adalah makhluk sosial adalah karena adanya komunikasi yang dilakukan antar manusia
tersebut. Dengan komunikasi, manusia sekaligus menjalin hubungan dengan manusia lainnya dan
membentuk sebuah koneksi dengan manusia lainnya melalui ikatan emosional dan juga cerita yang
disampaikan. Hal ini menjadi sebuah dasar yang dapat dipelajari, dan dijadikan sebuah ilmu
pengetahuan yang banyak dipelajari oleh bidang linguistik.
Komunikasi memiliki sebuah peranan penting untuk bertukar informasi antar manusia.
Biasanya komunikasi dilakukan menggunakan sebuah bahasa yang disepakati dan dimengerti
bersama, agar informasi yang ditukar dan disampaikan dapat dimengerti dengan manusia lainnya.
Bahasa ini disebut juga dengan natural language (bahasa natural). Beberapa contoh bahasa yang
disebut juga dengan bahasa natural antara lain adalah bahasa ibu, yang berarti bahasa yang kita
gunakan sejak lahir, yang biasanya merupakan bahasa yang digunakan di negara tempat kita tinggal.

5
 Apabila kita lahir dan tinggal di Indonesia sejak kecil, maka dapat dipastikan bahwa
kemungkinan besar bahasa natural yang kita miliki adalah Bahasa Indonesia. Mungkin bahasa ini
akan berbeda untuk orang lain yang tinggal di negara lain, misalkan di Amerika. Orang Amerika
akan cenderung berbicara menggunakan Bahasa Inggris. Agar sesama manusia dapat berkomunikasi
antar satu dengan yang lainnya, maka disepakatilah sebuah bahasa yang dapat digunakan secara
universal, yaitu Bahasa Inggris.
Sebuah bahasa natural umumnya mempunyai sebuah struktur dan juga imbuhan yang
biasanya dapat mencerminkan perasaan ataupun maksud dari orang yang berbicara, untuk
menekankan informasi yang disampaikan. Hal ini yang membuat bahasa natural berbeda dengan
bahasa pemrograman yang digunakan oleh komputer. Ketika kita mempelajari Machine Learning,
umumnya bahasa yang kita gunakan adalah bahasa pemrograman Python. Bahasa ini tidak
memiliki sebuah ekspresi dan konteks, dan untuk mengerti konteksnya, diperlukan adanya domain
knowledge. Berbeda dengan bahasa natural, dimana bahasa yang disampaikan dapat berisi sebuah
emosi, makna, bersifat ambigu, dan memiliki konteks. Bahasa natural juga memiliki kemampuan
untuk beradaptasi dari waktu ke waktu, dan mungkin akan muncul bahasa atau istilah baru yang
digunakan dalam masyarakat. Struktur yang digunakan juga dapat berubah mengikuti status sosial
manusia, kultur, dan juga teknologi yang ada.

Apa itu Natural Language Processing?

Dengan semakin majunya teknologi, banyak peneliti yang mencoba untuk mengembangkan
teknologi yang ada agar dapat beradaptasi dengan bahasa natural yang dimiliki manusia. Harapan
besarnya adalah suatu saat nanti, bahasa pemrograman yang ada dapat berevolusi untuk mengikuti
bahasa natural yang dimiliki manusia. Untuk itu, ada sebuah bidang dalam Artificial Intelligence
yang mempelajari bidang tersebut, dimana bidang ini dinamakan Natural Language Processing
atau biasa disebut dengan NLP. Dengan adanya NLP ini, diharapkan sebuah komputer dapat
mengerti dan menginterpretasikan bahasa natural manusia dan bisa menghasilkan bahasa yang
menyerupai dengan bahasa natural manusia.

6
Aplikasi NLP
NLP berperan penting dalam kehidupan manusia pada jaman ini. Beberapa aplikasi yang ada
yang melibatkan NLP seperti mesin penerjemah, yang mungkin sering kita gunakan seperti Google
Translate. Kita mungkin juga sering mendengar aplikasi NLP seperti Voice Recognition yang dapat
mengenali suara, lalu Sentiment Analysis yang dapat menarik sebuah kesimpulan sentimen dari
sebuah kalimat. Selain itu, NLP juga banyak digunakan dalam pembuatan sebuah chatbots yang
digunakan untuk berkomunikasi dengan pelanggan secara otomatis. Dengan adanya NLP ini,
diharapkan pada suatu saat nanti, komputer juga dapat berinteraksi dengan manusia menggunakan
bahasa natural manusia.

Istilah dalam NLP

Dalam mempelajari sebuah NLP, kita akan bertemu dengan banyak istilah yang akan
digunakan, seperti NLTK, tokenization, stop words, lemmatization, stemming, Part-of-Speech
Tagging (POS Tagging), dan Named Entity Recognition (NER). Kita juga akan menemukan
beberapa kegunaan dan fitur dari analisa teks seperti Semantics Analysis dan Sentiment Analysis,
juga Topic Modeling. Kita akan membahas masing - masing istilah satu persatu. Kita juga akan
menggunakan library Spacy untuk membantu kita menyelesaikan permasalahan NLP ini.

Apa Itu Spacy?

Spacy merupakan library Python bersifat open-source yang digunakan untuk menyelesaikan
permasalah NLP. Spacy ini dirancang untuk implementasi algoritma dasar yang dapat digunakan
untuk menyelesaikan permasalahan sederhana yang melibatkan NLP. Dengan hanya memiliki
algoritma dasar saja, terkadang kita tidak memiliki opsi lain ketika performa yang dihasilkan dengan
Spacy ini kurang baik. Alhasil, kita terkadang menggunakan metode lain untuk menyelesaikan
permasalahan NLP. Beberapa metode yang umum digunakan sebagai alternatif dari Spacy ini
meliputi penggunaan Supervised Learning dan Unsupervised Learning, juga Deep Learning.

7
 Berikut ini beberapa keuntungan yang kita dapatkan dengan
menggunakan library Spacy ini.

1. Performa : Spacy terkenal dengan efisiensi dari algoritma dan juga kecepatan pemrosesan
algoritmanya. Dengan ini, kita dapat mengolah data teks yang berjumlah besar dengan cepat.
2. Model yang telah dilatih sebelumnya : Spacy memiliki model statistik yang telah dilatih
sebelumnya dengan menggunakan beberapa bahasa natural, sehingga programmer tidak perlu
melatih model tersebut dari awal.
3. Tokenization : Spacy dapat menyelesaikan permasalah tokenization yang kompleks dengan
baik. Tokenization sendiri merupakan sebuah proses untuk memecah sebuah teks kalimat
sehingga dapat berdiri sendiri. Contoh umum dalam memecah teks kalimat adalah berdasarkan
karakter ‘spasi’, sehingga sebuah kalimat yang bertuliskan ‘Saya senang belajar Python’ akan
memiliki 4 token yang terdiri atas ‘Saya’, ‘Senang’, ‘Belajar’, dan ‘Python’. Dalam kasus
tertentu, kita juga bisa memecah berdasarkan huruf dalam sebuah kata.
4. Part-of-Speech Tagging (POS Tagging) : Spacy dapat dengan mudah memberikan POS
Tagging pada tiap kata dalam sebuah kalimat. POS Tagging merupakan proses untuk
pemberian tanda pada tiap kata yang membentuk sebuah kalimat, agar kata - kata yang diberi
tanda tersebut dapat dibedakan antara konteksnya, apakah kata tersebut merupakan sebuah kata
benda, kata sifat, objek, subjek, predikat, dan semacamnya.
5. Named Entity Recognition (NER) : Spacy dapat mengidentifikasi dan mengklasifikasikan
sebuah entitas, seperti nama orang, organisasi, nama lokasi, dan lainnya. NER ini biasa
digunakan apabila kita memiliki tujuan untuk mengetahui komponen 5W (what, who, where,
when, why) dalam sebuah kalimat.
6. Ketergantungan Antar Kata : Spacy dapat menganalisa ketergantungan antar kata, sehingga
apabila terdapat kata seperti ‘mata’ dan ‘mata-mata’, Spacy dapat membedakan arti dari kedua
kata tersebut, dimana kita tahu bahwa keduanya memiliki arti yang berbeda.

8
Apa Itu NLTK?
Selain Spacy, kita juga memiliki library lain, yaitu NLTK yang
merupakan singkatan dari Natural Language ToolKit. Library ini
populer karena merupakan sebuah library open source untuk mendukung
pembuatan model NLP. Library ini lebih tua dibandingkan Spacy, karena
sudah dirilis pada tahun 2001, sedangkan Spacy baru dirilis pada tahun
2015.

NLTK memiliki beberapa fitur yang sama dengan Spacy, namun NLTK juga memiliki fitur
lainnya yang berbeda dibandingkan dengan Spacy. Beberapa fitur NLTK antara lain adalah :
1. Corpora/Corpus : NLTK memiliki beberapa koleksi kumpulan teks yang telah diproses
sebelumnya, yang disebut dengan corpora. Kumpulan dari corpora ini biasanya disebut
dengan Corpus. Corpus ini juga tersedia dalam berbagai macam bahasa yang berbeda, dan
terdiri dari data teks yang telah dilatih sebelumnya seperti dataset yang populer seperti
WordNet, Penn Treebank, dan lainnya.
2. Tokenization : Sama seperti pada Spacy, NLTK juga memiliki fitur yang dapat digunakan
untuk memecah kalimat menjadi kata - kata individu.
3. POS Tagging : NLTK juga memiliki kemampuan untuk memberikan tanda pada tiap kata
yang diproses.
4. NER : NLTK memiliki modul yang dapat digunakan untuk mengklasifikasikan entitas.
5. Integrasi dengan WordNet : Fitur ini mungkin yang berbeda dengan Spacy. WordNet
sendiri dapat dianggap seperti bank kata - kata, dimana dalam WordNet ini ada banyak
sekali database berupa teks dalam Bahasa Inggris, dimana WordNet ini bisa jadi sumber
yang kita gunakan untuk melakukan pelatihan model seperti untuk pembuatan semantic
layer. Semantic Layer sendiri merupakan salah satu aplikasi dari NLP dimana kita dapat
mengubah bahasa yang digunakan dalam istilah bisnis ataupun sehari - hari menjadi bahasa
yang dimengerti oleh bahasa pemrograman.

9
 Umumnya, Semantic Layer ini diaplikasikan dalam merubah Bahasa
Inggris menjadi Bahasa Pemrograman SQL, yang digunakan untuk
mencari data melalui database.
6. Sentiment Analysis : Sentiment Analysis juga merupakan salah satu aplikasi dari NLP.
Sentiment Analysis memungkinkan kita untuk mencari tahu emosi yang ditimbulkan dari
sebuah kalimat, sehingga NLP dapat menentukan apakah kalimat tersebut berisikan emosi
positif, netral, ataupun negatif. Sentiment Analysis ini banyak digunakan untuk analisa
sebuah rating dan review dari pembeli sebuah produk.
7. Stop Words : NLTK memiliki sebuah bank data berisikan teks yang berisi informasi
mengenai Stop Words dari berbagai macam bahasa. Stop Words sendiri merupakan kata -
kata dalam sebuah kalimat yang tidak memiliki arti penting apabila dilakukan pemrosesan,
dan cenderung akan dibuang dari kalimat tersebut. Sebuah contoh kalimat berbahasa Inggris
“My Hobby is Playing Basketball” memiliki stop words, yaitu “My” dan “is”. Kedua
kata ini akan dibuang, sehingga ketika NLP memproses teks tersebut, kata - kata yang
terproses hanyalah “Hobby” dan “Playing Basketball”.
8. Lemmatization dan Stemming : Lemmatization dan Stemming merupakan kedua istilah
yang mirip, namun berbeda secara eksekusi. Persamaan dari keduanya adalah keduanya
akan menghilangkan imbuhan dari sebuah kata. Apabila kita memiliki kata - kata berikut :
[“waiting”, “waited”, “wait”], maka Lemmatization ataupun Stemming akan memotong
kata tersebut menjadi [“wait”, “wait”, “wait”] dimana kata dasar dari tiap imbuhan akan
ditampilkan. Pada Stemming, metode ini akan memotong imbuhan, sehingga apabila kita
memiliki kata “Cries” maka hasil stemming adalah “Cri”. Dalam bahasa inggris, kita tidak
memiliki arti dari “Cri” dan kita tahu bahwa kata dasar tersebut seharusnya adalah “Cry”.
Disini, Lemmatization memperbaiki kesalahan dari Stemming, dimana apabila kita
menggunakan Lemmatization, maka kata “Cries” akan menjadi “Cry”. Lemmatization
memanfaatkan informasi dari bank data pada WordNet untuk mencari dari bank kata.

10
Spacy VS NLTK
Pada pengolahan data berbentuk teks, kita umumnya menggunakan Spacy dan NLTK
sebagai library dasar yang dapat kita gunakan untuk membuat beberapa fitur tertentu yang
sederhana, seperti Sentiment Analysis, mencari Named Entity Recognition, POS Tagging, dan
lainnya. Namun ketika kita mengolah data teks dengan metode yang lebih tinggi lagi, tidak menutup
kemungkinan bahwa kita akan menggunakan beberapa library lainnya yang mungkin kita sudah
kenal dan bahas sebelumnya pada Bab sebelumnya, seperti pandas, numpy, scikit-learn, dan juga
beberapa library Deep Learning lainnya seperti Tensorflow, Keras, dan juga PyTorch.
Pada bagian ini, kita akan membicarakan saja dua library basic yang mungkin umum
digunakan untuk memproses data teks sederhana, yaitu Spacy dan NLTK. Sebelumnya kita telah
menjelaskan bagaimana kedua library tersebut dapat digunakan untuk melakukan proses pengolahan
teks sederhana. Kita akan mencoba untuk menggambarkan perbedaan kedua library ini pada tabel
berikut ini.

Spacy NLTK

Spacy terdiri atas beberapa model Fungsi pada NLTK lebih banyak
Arsitektur Library terpilih yang memiliki performa digunakan untuk mendukung
baik pengerjaan sebuah proses

Karena kebanyakan fungsinya

Spacy mudah untuk digunakan, dan
adalah fungsi untuk pendukung
penulisan sintaks hanya
Penulisan Sintaks sebuah proses, maka umumnya kita
membutuhkan beberapa baris kode
masih perlu menuliskan sintaks
saja
lainnya sesuai kebutuhan proses

Spacy memiliki performa yang baik Secara performa, mungkin tidak

karena sudah diatur hanya secepat Spacy, namun lebih
Performansi menggunakan model dan parameter fleksibel, dan NLTK lebih banyak
terbaik saja. Namun hal ini menyediakan fungsi dan algoritma
mengurangi fleksibilitas model. pengolahan data teks

11
Konsep dan Teori NLP
Konsep dasar Spacy
Kita telah membahas sekilas mengenai apa itu NLP, dan juga beberapa library yang
mungkin dapat digunakan untuk membantu kita untuk memproses teks. Kita mengetahui bahwa
komputer dapat dengan mudah memproses data yang bersifat numerik, namun hal ini akan berbeda
dengan data berbentuk teks ataupun bahasa natural. Bahasa natural yang ada pun beragam dan tiap
bahasa natural memiliki kesulitannya masing - masing.
Pada Spacy, kita bisa memanggil fungsi nlp() untuk melakukan pemrosesan teks. Berikut
ilustrasi yang terjadi ketika kita menggunakan fungsi nlp() ini.

Fungsi nlp() dari Spacy akan mengambil teks mentah dan melakukan beberapa proses
operasi seperti memberikan tag, parser, dan operasi NER. Kita akan mencoba untuk melihat
sekilas mengenai cara kerja dari fungsi ini.

Apabila kita tidak memiliki library Spacy pada Google Colab yang kita gunakan, kita
dapat menginstal library tersebut terlebih dahulu dengan menggunakan perintah !pip install spacy.
Ini akan membuat Google Colab mendownload library tersebut dari PyPI menggunakan package
installer. Setelah proses tersebut selesai, kita akan mencoba untuk memanggil library Spacy
tersebut.

12
 Kita akan menggunakan import spacy untuk memanggil library spacy tersebut. Model data
yang akan kita pakai adalah en_core_web_sm. Model ini merupakan database yang disediakan oleh
Spacy yang sebelumnya telah dilatih, dan dapat kita gunakan untuk melakukan pemrosesan data
teks yang kita miliki. Kata - kata en_core_web_sm berarti adalah inti data (‘core’) dalam bahasa
inggris (‘en’) yang diambil dari internet (‘web’) dengan ukuran datanya kecil (‘sm’). Kita dapat
melihat model - model data yang digunakan pada dokumentasi dari Spacy itu sendiri. Kita juga
akan menuliskan sebuah teks, yaitu “The quick brown fox jumps over the lazy dog”. Teks ini
akan kita masukan pada fungsi nlp() yang kita buat, lalu hasilnya kita masukan pada variabel
output.

Kita akan mencoba beberapa fungsi dasar yang terdapat pada Spacy. Kita bisa
menggunakan fungsi .text untuk memecah kalimat per kata dengan melakukan tokenization. Kita
juga melihat fungsi .pos_ untuk mengeluarkan Part-of-Speech pada tiap kata, yang menentukan
fungsi kata tersebut dalam kalimat. Lalu kita juga dapat mengeluarkan .dep_ yang merupakan
dependancy, menandakan kata mana yang merupakan inti dari kalimat tersebut, dan kata mana yang
memiliki ketergantungan dengan kata lainnya. Untuk melihat apa yang terjadi dalam fungsi nlp()
tersebut, kita bisa melihat isi dari pipeline fungsi tersebut.

13
 Kita juga dapat melihat fungsi dari masing - masing pipeline tersebut.

Kita akan membahas masing - masing dari fungsi ini nanti pada bagian selanjutnya. Kita
akan mencoba untuk melihat beberapa fungsi dasar lainnya dari Spacy yang dapat kita gunakan.

Tag Deskripsi teks.tag

Mengambil potongan kata

.text jumps
dari sebuah kalimat

Mengambil bentuk dasar

.lemma_ jump
dari kata tersebut

Menampilkan tag dari POS-

.pos_ VERB
Tagging

Menampilkan informasi
.tag_ VBZ
detail dari POS-Tagging

.shape_ Menampilkan ukuran kata xxxx

Mengecek apakah sebuah

.is_alpha True
token merupakan alfabet

Mengecek apakah token

.is_stop tersebut bagian dari stop False
words

Selain memecah kata di dalam sebuah kalimat, kita juga bisa memecah kalimat pada sebuah
paragraf. Kita menggunakan fungsi .sents untuk memecah paragraf/kumpulan teks tersebut menjadi
masing - masing kalimat. Perhatikan contoh berikut ini.

14
Konsep dasar Tokenization
Kita sudah beberapa kali menyebutkan istilah token ataupun tokenization pada pembahasan
mengenai bagian konsep NLP sebelumnya, maupun penggunaan dasar Spacy. Tokenization
merupakan sebuah proses untuk memecah teks asli menjadi beberapa komponen, yang disebut
dengan token. Berikut ini merupakan ilustrasi bagaimana proses tokenization terjadi.

Pada awalnya, proses tokenization akan memisahkan seluruh kata dalam kalimat tersebut
berdasarkan karakter spasi yang ada. Proses tersebut akan berlanjut dengan memisahkan Prefix
yang merupakan karakter pertama, lalu Suffix yang merupakan karakter terakhir, dan Exception
yang merupakan bentuk pengecualian yang bukan berupa karakter alfabet. Untuk menyimpulkan
proses yang kita lakukan, mari lihat tabel berikut ini.

15
 Proses Deskripsi Contoh

Prefix Karakter pada awal kalimat $ , (, “

Suffix Karakter pada akhir kalimat km, ), ., !, ?, “, )

Karakter antara awal dan

Infix - , --, …
akhir kalimat

Aturan khusus untuk

membagi sebuah teks
menjadi beberapa token,
Exception let’s go
biasanya berisikan karakter
khusus seperti tanda
apostrophe (‘)

Ketika kita memecah kalimat tersebut menjadi beberapa token, kita belum akan mengubah
kata tersebut menjadi kata dasarnya (lemmatization/stemming), karena pada proses ini kita hanya
memecah kalimat tersebut, untuk digunakan pada proses selanjutnya. Kita akan melihat contoh cara
penulisan sintaks untuk melakukan tokenization ini.

16
Karakter Khusus
Proses tokenization ini juga bisa membedakan sebuah kalimat yang berisikan karakter
khusus, seperti e-mail, ataupun mata uang. Perhatikan penulisannya berikut ini.

Perhatikan juga bagaimana tokenization dapat memecah teks yang berisikan nominal mata
uang didalamnya.

17
 Ketika kita memecah nominal mata uang, simbol mata uangnya dipisahkan dengan
tokenization, namun nominalnya masih menyatu menjadi sebuah kesatuan. Dengan ini
menunjukkan bahwa nilai nominal angka tidak akan dipecah secara terpisah oleh proses
tokenization ini.

Slicing dan Indexing

Dengan menggunakan len, kita bisa mengecek jumlah token yang ada dalam kalimat. Kita
pun dapat melakukan proses slicing seperti yang sama kita lakukan pada pengolahan tipe data
string. Kita bisa menggunakan index untuk memanggil token yang kita inginkan. Berbeda dengan
operasi pada string, bahwa pada token kita tidak bisa memberikan baru pada lokasi index pada
token tersebut.

Entitas
Operasi dasar lainnya yang dapat kita lakukan dengan Spacy adalah mengecek entitas yang
berada dalam sebuah kalimat. Dengan Spacy, kita bisa menentukan entitas apa yang sedang
dibicarakan dalam sebuah kalimat berdasarkan kumpulan data yang dimiliki oleh Spacy. Perhatikan
contoh berikut ini.

18
 Kita menggunakan tag .ents untuk mengeluarkan entitas dari kalimat tersebut. Kita juga
akan mengeluarkan label dari entitas tersebut dengan menuliskan entity.label_. Kita juga dapat
mengambil fungsi spacy.explain dari Spacy untuk menjelaskan arti dari tiap entity.label_ tersebut.
Kita lihat bahwa Spacy dapat mengetahui dengan pasti arti dari tiap entitas, termasuk bisa
mendefinisikan nama seseorang, nama perusahaan, dan juga nilai nominal uang.

Noun Chunks
Noun Chunks dikenal juga dengan frasa dari kata benda. Seluruh kata benda dalam kalimat
dan kata - kata yang berhubungan dengan benda tersebut akan ditampilkan sebagai noun chunks.
Pada Spacy, kita bisa melihat noun chunks tersebut dengan menuliskan tag .noun_chunks.
Perhatikan contoh penulisan sintaks berikut ini.

19
 Pada kalimat tersebut, Natural Language Processing akan dianggap sebagai kata benda,
sedangkan a subset study dan Artificial Intelligence sebagai pendukung dari kata benda tersebut.
Sehingga ketika kita memanggil noun chunks, ketiganya akan ditampilkan.

Konsep dasar Stemming

Stemming merupakan proses untuk memotong kata yang memiliki imbuhan untuk
mendapatkan kata dasar yang digunakan. Contoh proses stemming ini adalah apabila kita memiliki
kata : “Menjauh”, “Jauh”, “Dijauhi”, maka ketika kata tersebut akan dikonversi menjadi “jauh”,
“Jauh”, “jauh”. Permasalahan ini banyak terjadi apabila kita menggunakan Bahasa Inggris. Kita
terkadang memiliki sebuah kata yang merupakan kata benda, namun apabila menjadi sebuah kata
sifat maka akan ada imbuhan yang mengikuti. Sebagai contoh, kata Bahasa Inggris : “Close”,
“Closely”, “Closer”, maka ketiga kata ini akan diubah menjadi “Close”.
Stemming akan memotong kata tersebut sampai kata dasar ditemukan dari kata tersebut.
Dalam Bahasa Inggris, ini dapat menjadi masalah, karena akan membuat kita kehilangan bagian
dari sebuah kata. Sebuah kata dalam Bahasa Inggris seperti “Cries” apabila kita gunakan stemming,
maka akan menjadi “Cri”. Dalam Bahasa Inggris, kata dasar tersebut seharusnya adalah “Cry” dan
bukan “Cri”. Hal ini disebabkan karena stemming hanya akan memotong saja tanpa mengerti
artinya.
Library Spacy yang kita gunakan tidak memiliki sebuah stemmer. Pembuat dari library ini
pun sengaja tidak memasukkan stemmer, dan sebagai gantinya memasukkan library untuk
melakukan lemmatization. Berdasarkan referensi dari halaman ini, algoritma Porter yang
digunakan untuk melakukan stemming akan menduplikasi kata tersebut. Pada Spacy, stemming
tidak diprioritaskan karena akan mempengaruhi performa, dan juga lemmatization memiliki
keunggulan yang lebih baik dibandingkan stemming.

20
 Pada algoritma Porter, kita memiliki lima fase untuk melakukan reduksi terhadap sebuah
kata. Berikut ini merupakan jenis mapping yang dibuat oleh Porter.

Pada fase diatas, beberapa kata yang memiliki imbuhan akhir seperti pada kolom S1 akan
tereduksi menjadi S2. Kita dapat lihat contohnya pada tabel bagian kanan. Dari aturan stemming
yang dibuat, hanya ada 1 aturan yang dapat diaplikasikan pada sebuah kata, dan dipilih berdasarkan
suffix yang terpanjang, sehingga caresses akan tereduksi menjadi caress.

Fase lain yang lebih kompleks meliputi dari panjangnya ataupun kompleksitas dari kata
tersebut sebelum sebuah aturan diaplikasikan. Contohnya seperti pada gambar diatas.
Nama bahasa stemming yang dibuat oleh Martin Porter, yang merupakan salah satu orang
yang mengembangkan algoritma stemming ini adalah Snowball. Algoritma yang dilakukan ini
dapat disebut dengan English Stemmer atau Porter2Stemmer. Algoritma ini memiliki beberapa
pengembangan yang jauh lebih baik dibandingkan dengan stemmer Porter sebelumnya, baik dalam
logika dan kecepatannya.
Karena kita tidak memiliki algoritma stemming pada Spacy, kita akan mencoba untuk
melihat aplikasi dari stemming ini dengan menggunakan library NLTK.

21
 Perhatikan bahwa beberapa kata “Close” berhasil ditemukan oleh stemmer. Kata seperti
“Closer” dan “Closest” tidak bisa dideteksi oleh stemmer. Kita mencoba contoh lain seperti kata
“Cry”, “Cries”, “Crying” sedangkan seluruhnya berubah menjadi “cri”. Kita akan mencoba
metode kedua dari Porter, dengan menggunakan Snowball.

Walaupun kita menggunakan Snowball, kita tetap mendapatkan hasil yang sama dengan
ketika kita menggunakan Porter Stemmer sebelumnya.

22
 Dengan hasil yang didapatkan menggunakan stemmer, kita kurang mendapatkan hasil yang
akurat dalam mencari kata dasar. Kita akan mencoba untuk mempelajari konsep lemmatization yang
memiliki fungsi mirip dengan stemmer.

Konsep dasar Lemmatization

Lemmatization merupakan proses untuk menemukan kata dasar dari sebuah kata yang
memiliki imbuhan. Apabila kita ingat definisi dari stemming sebelumnya, lemmatization memiliki
tujuan yang sama seperti stemming. Perbedaan yang membuat kedua metode ini sangat kontras
adalah dengan menggunakan stemming, maka kata tersebut akan direduksi, tanpa memperhatikan
maknanya. Lemmatization akan melihat arti dari kata yang tereduksi, lalu mencari arti dari
keseluruhan kata tersebut dan melakukan analisa sederhana untuk mengerti arti dari kata dasar
tersebut. Dengan demikian apabila menggunakan lemmatization, sebuah kata seperti “Meeting”
akan tereduksi menjadi “Meet” ataupun “Meeting” tergantung dari konteks kalimat tersebut. Hal
ini yang membuat Spacy hanya memiliki lemmatization dan tidak memiliki stemming.
Proses yang dilakukan oleh lemmatization adalah akan melihat dari teks yang berada
disekitar kata yang akan kita reduksi tersebut untuk menentukan POS Tagging dari kata tersebut.
Dengan demikian, lemmatization sangat bergantung pada POS Tagging, dan akan mengabaikan
frasa apabila frasa tersebut tidak dapat diberikan POS Tagging. Kita akan mencoba untuk membuat
lemmatization dengan menggunakan Spacy. Perhatikan gambar berikut ini.

23
 Kita akan memasukkan nilai dari token, POS, dan juga lemma itu sendiri kedalam list, lalu
kita akan menampilkannya dalam bentuk Dataframe agar lebih mudah untuk dilihat. Perhatikan
kita memiliki 3 bentuk penulisan kata “Swim” dimana “Swimmer” merupakan kata benda,
“Swimming” merupakan kata kerja, dan “Swam” juga merupakan kata kerja masa lampau. Kita
akan lihat bagaimana Spacy mengolah data tersebut.

24
 Perhatikan bahwa pada beberapa kata, lemmatization mengubah kata tersebut menjadi kata
dasar seperti “am” menjadi “be” dan “swimming” menjadi “swim”. Kata seperti “swam”
walaupun dalam masa lampau, tetap dianggap sebagai sebuah kata dasar oleh Spacy.

Konsep dasar Stop Words

Dalam Bahasa Inggris, kita memiliki beberapa kata yang mungkin sering muncul dalam
sebuah kalimat, namun tidak memiliki arti tertentu dalam kalimat. Contoh dari kata - kata tersebut
adalah : “Is”, “a”, “the” dan masih banyak lainnya. Kata - kata tersebut tidak perlu untuk diberikan
sebuah POS Tagging. Kita menyebut kata - kata tersebut merupakan sebuah stop words, dan ketika
kita akan melakukan analisis terhadap teks, kita umumnya membuang kata - kata tersebut dari
kalimat. Spacy memiliki sebuah list berisikan total 326 stop words berbahasa Inggris.

Untuk menampilkan seluruh stop words yang ada pada Spacy, kita bisa menuliskan
nlp.Defaults.stop_words. Sintaks ini akan menampilkan seluruh stop words yang dimiliki oleh
Spacy.

25
 Kita dapat mengecek jumlah stop words yang ada pada library Spacy dengan menggunakan
len().

Kita juga dapat mengecek apakah sebuah kata merupakan stop words atau bukan dengan
menggunakan fungsi is_stop.

Kita juga dapat menambahkan sendiri stop words yang kita inginkan. Hal ini biasa kita
lakukan ketika kita menginginkan untuk menganalisis sebuah teks ataupun paragraf yang memiliki
kata - kata yang sering sekali muncul, membuat kita tidak memerlukan analisa lebih lanjut untuk
kata tersebut. Kita bisa menggunakan .add() untuk menambahkan stop words tersebut. Kita juga
akan mencoba untuk melihat jumlah stop words yang ada sekarang.

Selain kita bisa menambahkan stop words kita sendiri, kita juga bisa menghapus sebuah
stop words dari list yang ada pada Spacy. Kita akan melakukan hal sebaliknya dari menambahkan
stop words. Perhatikan sintaks berikut.

26
 Dengan menggunakan perintah .remove(), kita bisa menghapus stop words yang ada dari
list stop words. Kita juga akan memasang vocab dari Coffee tersebut menjadi False. Hal yang kita
lakukan merupakan hal kebalikan dari menambahkan stop words, sehingga ketika kita cek kembali
jumlah stop words yang ada, sekarang jumlahnya kembali menunjukkan angka 326.

Konsep dasar Phrase Matching

Kita telah melihat bagaimana sebuah kalimat dapat dipecah menjadi beberapa kata yang
berdiri sendiri, lalu bagaimana caranya kita dapat memberikan sebuah tag pada masing - masing
kata tersebut, lalu juga dapat menyederhanakan kata tersebut dengan lemma. Pada Phrase
Matching, kita akan mencoba untuk melabeli frasa tertentu yang telah kita tentukan sebelumnya.
Ide dari Phrase Matching adalah dengan menggunakan rule-based matching, dimana kita
akan menggunakan sebuah fungsi Matcher, lalu kita akan mencoba membuat sebuah library yang
memiliki pola pada token, lalu kita dapat mencocokan bagian pada token tersebut dengan bagian
dari sebuah kalimat. Fungsi Matcher tersebut akan mengembalikan lokasi dari pola yang
ditemukan dalam frasa apabila ia menemukan pola yang telah kita tentukan sebelumnya. Perhatikan
bagaimana cara kita menuliskan sintaks untuk mencari pola tersebut.

27
 Untuk menggunakan fungsi Matcher, kita akan memanggilnya dari library spacy.matcher.
Kita akan membuat list matcher dalam variabel matcher. Kita akan membuat tiga pola disini yang
diwakili oleh pattern1, pattern2, dan pattern3. Pola ini akan dikemas dalam sebuah dictionary.
Key dari dictionary tersebut dapat dilihat dalam dokumentasi Spacy berikut ini. Pada pattern yang
kita buat, kita akan menggunakan key LOWER untuk membuat token tersebut menjadi huruf
kecil. Kita juga menyatakan bahwa tiap token tersebut adalah sebuah punctuation dengan
IS_PUNCT. Setelah kita memiliki tiga bentuk, dimana bentuk pertama adalah kata ‘solarpower’
yang digabungkan, lalu bentuk kedua adalah kata ‘solar’ dan ‘power’ yang terpisahkan oleh kata
lain ditengahnya, dan bentuk ketiga adalah 2 kata ‘solar’ dan ‘power’ yang terpisah berurutan, kita
akan memasukkan ketiga pola tersebut.

Kita akan memasukkan pola tersebut dalam sebuah list_patterns, lalu kita akan
menggunakan fungsi .add() untuk menambahkan frasa dan juga list_patterns kedalamnya. Kita
memberikan keyword argument on_match = None, dimana on_match ini berperan untuk
menentukan output dari fungsi callback yang telah ditentukan Spacy sebelumnya. Kita akan
menonaktifkan fungsi ini, dan akan menampilkan output yang hanya berupa ID dari match yang
ditemukan, dan juga posisi index-nya. Perhatikan sintaks berikut ini.

28
 Kita akan membuat sebuah frasa dan kita memasukkannya dalam variabel phrase1. Dalam
frasa ini, kita melihat ada 3 bentuk kata SolarPower, dimana yang pertama adalah “Solar Power”,
yang kedua adalah “solarpower”, dan yang ketiga adalah “Solar-Power”. Kita akan memasukkan
frasa ini dalam fungsi matcher kita lalu kita akan lihat outputnya.
Output yang dihasilkan terdiri atas match_id, diikuti dengan posisi index dimulai dan posisi
index akhir dari lokasi frasa yang ditemukan. Karena kita memiliki 3 pola, maka output tersebut
akan berbentuk list dari hasil penemuan masing - masing pola. Untuk membuat bentuknya lebih
mudah untuk dilihat, kita akan menggunakan iterasi untuk menampilkan masing - masing pola yang
ditemukan.

Kita akan mencoba untuk mengganti pola yang telah kita buat. Untuk itu, kita akan
menghapus terlebih dahulu frasa yang kita tentukan sebelumnya pada fungsi Matcher kita. Kita
akan membuat sebuah pola baru yang terdiri dari 2 pola berbeda, dimana pola pertama akan
memuat “solarpower” yang digabungkan dan pola kedua adalah kata “solar” dan “power” yang
terpisah. Pada bagian IS_PUNCT, kita akan menambahkan operator wildcard “*”, yang berarti kita
akan mencari seluruh pola dan memperbolehkan adanya pengulangan apabila fungsi Matcher
menemukan lebih dari 1 hasil dari pola kedua. Perhatikan penulisan sintaksnya berikut ini.

29
 Setelah kita membuat bentuk pola keduanya, kita akan melakukan hal yang sama seperti
sebelumnya, yaitu memasukkan pola tersebut dalam fungsi Matcher kita.

Kita akan membuat sebuah frasa baru. Kita akan mencoba untuk membuat frasa tersebut
secara acak, hanya untuk mencoba apakah pola baru yang kita buat dapat mendeteksi frasa tersebut
dengan benar.

Kita akan mencoba untuk menggunakan iterasi untuk menampilkan hasil yang lebih jelas.

Pada hasil yang kedua, kita melihat bahwa operator wildcard yang kita gunakan dapat
mendeteksi kata “solar--power” walaupun kata tersebut terpisahkan oleh token lainnya.
Kita telah mencoba untuk membuat sebuah Matcher dengan menggunakan rule-based
matcher yang menggunakan token. Setelah ini kita akan mencoba untuk menggunakan phrase-
based matcher, untuk membuat sebuah Matcher berdasarkan frasa, yang dinilai lebih efisien
dibandingkan rule-based matcher.

30
 Kita akan memanggil fungsi PhraseMatcher dari library Spacy. Kita juga akan kembali
memanggil database ‘en_core_web_sm’ kita. Kita akan memasukkan fungsi PhraseMatcher()
kedalam variabel matcher.

Kita akan mencoba untuk membaca sebuah teks yang lebih panjang. Sebelumnya dengan
menggunakan rule-based matcher, kita membuat sendiri kalimat kita, dimana kalimat masih
pendek. Kita akan mengambil narasi dari halaman wikipedia Avengers Endgame, yang kita
simpan dalam sebuah text editor. Kita akan membaca teks tersebut dengan menggunakan Python.
Teks tersebut akan disimpan dalam text editor bernama AvengerEndgame.txt (perhatikan lokasi
penyimpanan file ini bisa berbeda dengan yang kalian miliki di Google Colab).

Kita akan membuat 3 macam frasa yang mungkin banyak muncul dalam teks tersebut, yaitu
“Stark”, “the Avengers”, dan “Thanos”. Kita akan memasukkan frasa tersebut dalam sebuah list,
lalu membuat ketiga frasa tersebut menjadi sebuah frasa yang dapat dibaca oleh Spacy.

Setelah ini, frasa tersebut akan kita masukkan dalam matcher yang kita buat sebelumnya.
Kita bisa menggunakan matcher untuk menampilkan lokasi dari frasa yang ditemukan pada teks.

31
 Ketika kita jalankan sintaks tersebut, kita dapat melihat sejumlah hasil yang mencerminkan
lokasi ditemukannya masing - masing frasa dalam teks yang berada pada text editor tersebut.

Untuk mempermudah pembacaan frasa tersebut, kita dapat melakukan iterasi sama seperti
yang kita lakukan ketika menggunakan rule-based matcher sebelumnya.

Ketika kita menjalankan sintaks diatas, kita akan melihat tampilan dari frasa yang telah kita
tentukan. Perhatikan hasilnya berikut ini.

32
 Perhatikan bahwa output yang ditampilkan diatas hanya menampilkan frasa yang kita
tuliskan sebelumnya ketika kita membuat sebuah pola. Untuk melihat kalimat yang mengandung
frasa tersebut, kita bisa memberikan rentang jarak 5 kata sebelum dan sesudah frasa, untuk dapat
menampilkan keseluruhan kalimat yang mungkin mengandung frasa tersebut. Perhatikan penulisan
sintaksnya berikut ini.

Apabila kita jalankan sintaks diatas, maka kita akan mendapatkan hasil seperti berikut ini.

33
 Dengan menggunakan teknik tersebut, kita dapat menampilkan sebuah kalimat yang
mengandung frasa tersebut.

Konsep dasar Part-of-Speech Tagging (POS Tagging)

Part-of-Speech Tagging atau POS Tagging ini berfungsi untuk membantu kita untuk
memberikan sebuah anotasi khusus pada sebuah kata. Ingat bahwa pada Spacy, kita akan
memberikan sebuah data teks mentah yang akan diolah menjadi sebuah objek Doc, dimana pada
objek Doc ini telah terdapat banyak anotasi yang dilakukan oleh Spacy sebelumnya. Hal ini
sangatlah penting untuk dilakukan, karena banyak kata - kata yang sama yang akan memiliki
anotasi berbeda, tergantung konteks dari kalimat yang ada. Sebagai contoh, penulisan kalimat : “I
want to go to the park” dan “Do not park your car here!”, kedua kalimat tersebut memiliki kata
“park” dimana fungsi kata “park” dalam kedua kalimat tersebut berbeda. Pada kalimat pertama,
kata “park” akan menjadi sebuah kata benda sedangkan pada kalimat kedua merupakan kata kerja.
Spacy akan mempermudah kita untuk memberikan konteks dari kata tersebut.

34
 Kita akan mencoba untuk melihat dua macam tag pada POS Tagging ini. Yang pertama
adalah coarse POS tags dimana tag ini akan berisikan tag untuk noun, verb, dan adjective dalam
bahasa inggris. Yang kedua adalah fine-grained tags yang akan berisikan tag untuk plural noun,
past-tense verb, superlative adjective. List dari isi tag ini dapat sewaktu - waktu diperbarui oleh
Spacy. Perhatikan gambar berikut ini untuk coarse POS tags.

Perhatikan juga gambar berikut ini yang memuat kumpulan dari fine-grained tags.

35
 Setelah memahami kedua jenis tag tersebut, kita akan mencoba memahami lebih lanjut
mengenai tag tersebut dalam sintaks Python.
36
 Seperti biasa kita pertama akan memanggil library Spacy yang digunakan, lalu memanggil
database “en_core_web_sm” yang juga akan kita gunakan.

Kita akan membuat sebuah kalimat dan menjadikan kalimat tersebut objek Spacy. Kita juga
akan mencoba untuk melihat secara acak sebuah tag yang diberikan oleh Spacy pada salah satu
kata tersebut.

Kita akan mencoba untuk melihat keseluruhan tag yang diberikan oleh Spacy. Perhatikan
sintaks berikut ini.

Perhatikan bahwa Spacy dapat memberikan dan menerjemahkan tag dari masing - masing
kata yang terbentuk. Kita menggunakan :{10} untuk merapihkan tampilan string agar lebih enak
untuk dilihat. Kita akan mencoba untuk menggunakan contoh lain untuk mengetahui apakah Spacy
bisa membedakan sebuah tag berdasarkan konteks dari kalimat tersebut. Kita akan mencoba untuk
menggunakan kata “park” yang telah kita bahas tersebut dan melihat perbedaannya.

37
 Seperti yang sudah dijelaskan pada bagian teori sebelumnya, kita melihat walaupun kata
yang digunakan sama - sama “park”, namun Spacy dapat membedakannya berdasarkan konteks
dari kalimat tersebut. Pada kalimat pertama yang berbunyi “I want to go to the park” akan
memiliki kata “park” yang berarti sebuah kata benda. Pada kalimat kedua yang berbunyi “Do not
park your car here!” akan memiliki kata “park” yang berarti sebuah kata kerja.
Kita akan mencoba untuk menggunakan contoh lain untuk melihat apakah Spacy bisa
membedakan kata yang berada di masa sekarang ataupun masa lampau. Perhatikan contoh berikut
ini.

Kita akan membaca tag dari kata “read” pada kedua kalimat diatas. Secara sekilas, kedua
kalimat tersebut memiliki arti yang mirip dimana keduanya memiliki arti “Saya membaca buku
tentang AI”. Namun ketika kita melihat tag dari keduanya, kita dapat melihat bahwa Spacy
memberikan fine-grained tag yang berbeda untuk kedua kata “read” tersebut.

38
 Apabila kita ingin melihat hubungan antar kata dalam Spacy, kita juga bisa membuat
visualisasi yang akan menghubungkan tiap kata dengan kata lainnya berdasarkan tag yang
diberikan. Fungsi yang digunakan untuk ini adalah displacy yang kita akan ambil dari library
Spacy. Perhatikan sintaksnya berikut ini.

Kita akan membuat sebuah kalimat baru, lalu kita akan mencoba untuk menampilkan hasil
visualisasinya dengan menggunakan displacy. Pada fungsi displacy, kita memberikan parameter
style yang berisikan ‘dep’ yang merupakan dependency, yang akan menampilkan visualisasi hasil
ketergantungan. Kita juga dapat memberikan parameter jupyter yang berarti kita akan
menampilkan gambar tersebut langsung pada Google Colab apabila kita jalankan sintaks tersebut.
Dokumentasi dari displacy ini dapat dilihat pada dokumentasi berikut ini. Kita akan menggunakan
render untuk menjalankan fungsi displacy tersebut.

Apabila kita menjalankan sintaks diatas, kita akan mendapat hasil berikut ini.

Pada dokumentasi mengenai displacy, kita juga memiliki parameter options. Kita bisa
mengatur sendiri isi dari parameter options tersebut untuk merubah tampilan dari gambar kita agar
memiliki gambar yang lebih baik dari segi warna, bentuk panah, jarak, dan lainnya. Keseluruhan
parameter yang dapat diberikan dapat dilihat pada dokumentasinya tersebut.

39
Konsep dasar Named Entity Recognition (NER)
Tujuan dari penggunaan Named Entity Recognition (NER) ini adalah untuk mendeteksi
dan mengklasifikasikan nama dari sebuah entitas yang disebutkan dalam sebuah kalimat menjadi
sebuah kategori tertentu, seperti nama dari seseorang, organisasi, lokasi, kode medis, waktu,
jumlah, nilai nominal tertentu, persentase, dan lainnya. Dengan adanya NER ini, kita dapat dengan
mudah mencari tahu komponen entitas penting yang berada dalam sebuah kalimat, dan dapat
memisahkan komponen tersebut apabila nantinya komponen entitas tersebut diperlukan dalam
sebuah analisis tertentu. Kita akan langsung mencoba aplikasi dari NER ini pada Python.

Kita akan memanggil library Spacy dan juga database yang biasa kita gunakan. Kita akan
membuat sebuah fungsi yang memudahkan kita untuk melakukan pengecekan NER nantinya pada
pembahasan NER berikutnya. Perhatikan sintaks fungsi tersebut.

Pada fungsi diatas, kita akan melakukan pengecekan pada kalimat, apabila kita menemukan
entitas, maka kita akan menampilkan entitas tersebut beserta label dan juga penjelasannya,
sedangkan apabila tidak ada entitas, maka kita hanya akan menampilkan “Tidak ada Entitas”.
Kita akan membuat sebuah kalimat sederhana, untuk mengecek apakah Spacy dapat
mendeteksi adanya entitas dalam kalimat tersebut. Perhatikan sintaks berikut ini.

40
 Ketika kita ingin mencari entitas pada kalimat “Hi, How are you?”, kita tidak akan
mendapatkan hasil entitas apapun. Hal ini dikarenakan pada kalimat tersebut tidak berisikan adanya
nama dari sebuah entitas, baik itu nama orang, organisasi, rentang waktu, dan lainnya. Ini
menyebabkan Spacy tidak dapat menemukan entitas apapun dalam kalimat tersebut. Kita akan
mencoba contoh lain dengan kalimat yang lebih panjang dan mencoba untuk mengecek apakah
Spacy dapat menemukan entitas dalam kalimat tersebut atau tidak. Perhatikan sintaks berikut ini.

Dari contoh kalimat diatas, perhatikan bahwa seluruh entitas yang ada pada kalimat tersebut
seperti Tony Stark, Avengers, dan Iron Man seluruhnya merupakan fiksi yang hanya ada pada
komik dan film. Walaupun demikian, Spacy masih dapat untuk membedakan tiap entitas yang ada
dalam kalimat tersebut menjadi beberapa entitas berbeda, seperti Tony Stark dan Iron Man yang
berhasil dikategorikan sebagai Person, lalu Stark Industries sebagai Companies, almost 15 years
yang merupakan sebuah rentang waktu, dan juga Avengers yang merupakan sebuah organisasi.
Kita akan mencoba untuk menggunakan kalimat lain sebagai contoh untuk menampilkan
label entitas lainnya. Perhatikan sintaks berikut ini.

41
 Untuk melihat keseluruhan entitas yang dapat didefinisikan oleh NER, kita dapat
melihatnya pada gambar berikut ini.

Terkadang, Spacy tidak dapat mendeteksi beberapa entitas yang kita ingin definisikan.
Apabila kita perhatikan contoh berikut ini :

Kita melihat bahwa Spacy tidak bisa mendefinisikan GOTO sebagai sebuah perusahaan,
dan rupiahs sebagai sebuah nominal uang. Kita akan mencoba untuk mendefinisikan sendiri kata
tersebut pada Spacy. Hal ini berguna apabila kita melakukan analisa untuk produk kita sendiri yang
tidak dikenali oleh Spacy sebelumnya.

42
 Untuk itu, kita akan mendefinisikan sendiri kata tersebut. Untuk itu, kita akan memanggil
fungsi Span dari library spacy.tokens. Perhatikan sintaksnya berikut ini.

Sintaks diatas akan mendefinisikan variabel ORG adn MON sebagai sebuah vocab baru
yang nantinya dapat kita tambahkan dalam library Spacy itu sendiri. Fungsi Span umum
digunakan untuk menambahkan sebuah entitas ataupun objek custom yang ingin kita tambahkan
secara manual pada Spacy. Kita akan membuat sebuah variabel baru yaitu new_org dan new_mon
yang akan memuat kata yang akan kita berikan label baru. Lalu kedua variabel ini akan kita
tambahkan ke dalam list entitas dari kalimat tersebut. Perhatikan sintaksnya berikut ini.

Setelah kita menambahkan kedua entitas tersebut dalam list entitas dari kalimat yang kita
buat sebelumnya, maka ketika kita memanggil kembali fungsi show_ents, kita dapat melihat bahwa
GOTO dan rupiahs telah terdefinisi.

Penambahan dari kategori entitas ini sangat berguna apabila kita ingin mendefinisikan
produk yang kita buat. Andaikan kita memiliki sebuah review dan ingin mendeteksi produk kita
yang kita buat sendiri sebagai entitas, yang mungkin sulit untuk dideteksi oleh Spacy, kita bisa
menambahkan sendiri entitas tersebut pada produk kita. Kita akan mencoba untuk menambahkan
sebuah entitas pada sebuah nama produk. Perhatikan contohnya berikut ini.

43
 Kita akan membuat sebuah kalimat yang berbunyi : “Our company made a new hazelnut
latte and macadamia latte coffee.”. Kita ingin menyatakan bahwa hazelnut latte dan
macadamia latte merupakan produk yang dibuat oleh sebuah perusahaan. Ketika kita
menggunakan fungsi show_ents(), dapat dilihat bahwa Spacy tidak mendeteksi adanya entitas pada
kalimat tersebut. Kita akan mendefinisikan sendiri hazelnut latte dan macadamia latte menjadi
sebuah produk. Untuk itu, kita akan menggunakan bantuan dari fungsi Phrase Matcher untuk
dapat mencari seluruh nama produk yang sesuai dalam kalimat tersebut.

Dengan menggunakan Phrase Matcher, kita menemukan lokasi index dari nama produk
yang kita tuliskan sebelumnya. Ingat bahwa 5 dan 7 dan juga 8 dan 10 adalah posisi index start dan
stop dari pola yang ditemukan pada Phrase Matcher. Kita dapat mengambil informasi dari tuple
tersebut untuk dapat kita masukkan sebagai iterasi ketika kita membuat sebuah entitas baru
nantinya. Setelah ini kita akan memanggil fungsi Span dari library spacy.tokens untuk
menambahkan entitas, sama seperti yang kita lakukan pada contoh sebelumnya. Perhatikan
penulisan dari sintaksnya berikut ini.

44
 Kita menggunakan iterasi pada variabel new_ents untuk mengambil seluruh posisi tuple
pada index 1 (start) dan index 2 (stop) dari seluruh hasil yang ditemukan pada found_matches.
Kita akan menambahkan entitas baru tersebut pada entitas awal yang kita miliki pada dokumen kita.
Sekarang apabila kita memanggil kembali fungsi show_ents(), sebelumnya kita tidak mendapatkan
entitas apapun karena Spacy tidak mendeteksi adanya entitas pada kalimat tersebut. Setelah kita
menambahkan entitas dengan bantuan dari Phrase Matcher, kita dapat melihat bahwa kita
sekarang memiliki entitas macadamia latte dan hazelnut latte sebagai sebuah Product.

Kita telah belajar bagaimana cara untuk menampilkan sebuah entitas dan juga
menambahkan entitas tersebut secara manual. Sekarang kita akan mencoba untuk membuat sebuah
visualisasi untuk entitas tersebut. Fungsi yang akan kita gunakan adalah fungsi displacy yang kita
gunakan sebelumnya untuk menampilkan visualisasi pada POS Tagging. Perhatikan sintaks berikut
ini.

Kita akan memanggil fungsi displacy tersebut. Setelah ini, kita akan kembali menggunakan
kalimat yang kita gunakan sebelumnya, lalu kita akan melakukan render. Perhatikan sintaks
berikut ini.

45
 Pada sintaks diatas, yang membedakan dengan yang kita gunakan sebelumnya pada POS
Tagging adalah pemberian parameter style yang kita gunakan. Sebelumnya kita menggunakan
‘dep’ untuk menampilkan dependency, pada NER, kita akan menggunakan ‘ent’ untuk
menampilkan entity. Ketika kita menjalankan sintaks diatas, kita akan melihat entitas yang
warnanya akan sesuai dengan tiap kategorinya. Kita bisa mengubah warna tersebut dengan
menambahkan parameter options. Dokumentasi mengenai bagaimana cara penambahan parameter
options tersebut dapat kita lihat pada dokumentasi berikut ini.

Konsep dasar Sentence Segmentation

Konsep dasar dari Sentence Segmentation mirip dengan yang kita lakukan dengan token.
Kita akan memecah kalimat sesuai dengan konsep yang mirip dengan token, dimana tag yang kita
gunakan .sents. Perhatikan sintaks berikut.

Kita akan memanggil kembali database spacy yang kita gunakan seperti biasa. Setelah ini,
kita akan mencoba membuat sebuah kalimat yang panjang, perhatikan contoh kalimat berikut.

Kita bisa memperhatikan bahwa kalimat diatas terdiri dari gabungan tiga kalimat yang
berbeda. Kita akan mencoba untuk memecah keseluruhan kalimat diatas berdasarkan kalimat yang
terbentuk. Untuk itu, kita akan menggunakan .sents. Perhatikan sintaks berikut ini.

46
 Untuk menampilkan tiap kalimat yang ada, kita akan memasukkan kalimat - kalimat
tersebut dalam sebuah list. Setelah itu, kita akan menampilkan isi dari masing - masing list tersebut.
Perhatikan bahwa dengan menggunakan tag .sents, kita berhasil untuk memecah kalimat tersebut
menjadi tiga kalimat berbeda. Hal ini dilakukan dengan membaca tanda baca (punctuation) yang
ada pada akhir kalimat (suffix), sehingga Spacy dapat memecah kalimat tersebut berdasarkan tanda
baca yang ada pada kalimat.

Aplikasi NLP
Banyak aplikasi dari NLP yang dapat diterapkan untuk mengolah data teks. Kita akan
membahas beberapa aplikasi dari NLP yang dapat diterapkan untuk mengolah data berupa teks.

Text Classification
Untuk melakukan klasifikasi terhadap sebuah data teks, kita menggunakan algoritma
Machine Learning. Namun, algoritma Machine Learning yang sudah kita pelajari tidak dapat
secara langsung mengolah data berbentuk teks, karena seperti yang telah kita bahas pada Bab
Machine Learning, kebanyakan algoritma yang kita gunakan berhubungan dengan rumus
matematika yang hanya dapat berfungsi untuk mengolah data berupa angka. Namun bukan berarti
kita tidak dapat mengolah data teks dengan Machine Learning. Kita perlu melakukan sebuah
ekstraksi fitur (feature extraction) terhadap data teks yang kita miliki, untuk mengubahnya menjadi
sebuah data numerik yang bisa diberikan pada algoritma Machine Learning yang kita kenal
sebelumnya, lalu mengembalikan data numerik tersebut kembali menjadi data teks.

47
 Untuk mengubah data teks menjadi data numerik, salah satu cara yang umum digunakan
adalah dengan menghitung berapa banyak jumlah kata tersebut muncul dalam sebuah teks, lalu kita
dapat memetakan kata tersebut menjadi sebuah angka. Dua metode yang dapat digunakan untuk
melakukan ekstraksi fitur ini adalah Count Vectorization dan Term-Frequency dengan Inverse
Document Frequency.
Metode Count Vectorization ini adalah metode dimana kita akan mengubah seluruh teks
yang kita berikan menjadi masing - masing token, lalu token tersebut akan dianggap sebagai fitur.
Kita akan menghitung berapa banyak jumlah kemunculan fitur tersebut dalam kalimat dengan
menggunakan Document Term Matrix. Sebagai contoh, anggap kita akan menggunakan kalimat :
“The quick brown fox jumps over the lazy dog”. Apabila kita menggunakan Count
Vectorization, maka kita akan membentuk Document Term Matrix seperti berikut ini.

Doc = “The quick brown fox jumps over the lazy dog”
Count Vectorizer

Data = [‘The’, ‘ quick’, ‘brown’, ‘fox’, ‘jumps’, ‘over’, ‘the’, ‘lazy’, ‘dog’]
Document Term Matrix

Metode lain yang dapat digunakan sebagai alternatif dari Count Vectorization adalah
TfidfVectorizer. Metode ini juga akan membuat sebuah Document Term Matrix (DTM) dari
teks yang kita miliki, sama dengan Count Vectorization. Namun berbeda dengan metode Count
Vectorization, DTM akan diisi dengan nilai Term Frequency-Inverse Document Frequency
(TF-IDF) untuk tiap kata.

48
 Term Frequency (TF) merupakan istilah yang digunakan untuk menghitung jumlah kata
yang muncul dalam sebuah dokumen. Namun, dalam sebuah kata seringkali kita menemukan kata
ataupun istilah yang akan muncul berkali - kali. Dalam Bahasa Inggris, contoh kata ini adalah “a”
atau “the”. Kata ini akan sering muncul dan umum dalam kalimat Bahasa Inggris yang kita
gunakan. Karena umum digunakan dalam sebuah kalimat, TF sendiri cenderung akan salah untuk
melakukan pembobotan terhadap kata tersebut. Kita tahu bahwa TF akan menghitung jumlah
kemunculan dari kata tersebut dalam teks yang kita miliki. Semakin banyak istilah “the” atau “a”
yang muncul, hal ini dapat diartikan oleh TF bahwa bobot kata tersebut dalam sebuah kalimat akan
sangat besar karena sering muncul, sedangkan kita tahu bahwa kata tersebut tidak memiliki arti
apapun dalam kalimat yang kita miliki. Untuk mengatasi masalah ini, kita menggunakan Inverse
Document Frequency (IDF) dimana IDF ini akan memberikan sebuah faktorisasi yang
menghilangkan nilai bobot dari kata yang memiliki nilai besar, dimana kata tersebut muncul berkali
- kali dalam dokumen kita, lalu kita akan menambahkan bobot untuk kata - kata yang memiliki
bobot sangat kecil atau yang jarang muncul dalam dokumen kita.
Untuk menghitung IDF, kita akan menghitungnya dengan menggunakan invers dari
logaritma dari jumlah kata yang muncul dalam dokumen tersebut. Perhatikan rumusnya berikut ini.

dimana :
N = Jumlah keseluruhan teks dalam dokumen
DFt = Document Frequency t, jumlah kata “t” yang muncul dalam dokumen

Metode TF-IDF ini sering digunakan agar kita dapat memahami konteks dan arti dari
kalimat yang terbentuk dari pembobotan kata - kata yang ada, dan tidak hanya mengetahui arti dari
masing - masing kata saja. Karena menggunakan metode Machine Learning, maka kita dapat
mencoba untuk menggunakan scikit-learn untuk membuat TF-IDF ini pada Python.

49
Studi Kasus : Pengkategorian sebuah teks Apakah Teks tersebut adalah Spam atau Bukan

Salah satu aplikasi yang umum digunakan untuk mengklasifikasikan sebuah teks adalah
untuk mengetahui apakah sebuah teks berisikan sebuah spam ataukah memang benar memiliki
informasi yang penting. Disini kita akan mengambil sebuah data dari Kaggle dimana kita akan
membaca sebuah data berisikan teks yang sudah diberikan klasifikasi apakah data tersebut
merupakan bohong (spam) ataupun benar (ham). Data tersebut dapat kita akses pada link berikut
ini.

Menyiapkan File

Kita akan mencoba untuk membaca file tersebut dan juga melakukan EDA terlebih dahulu,
untuk mengecek jumlah data dan apakah ada data yang berisikan nilai Null.

Kita akan mengecek dengan menggunakan fungsi isnull() dan sum() untuk mengecek
apakah ada data yang berisi Null.

50
(Opsi 1) Melakukan Pre-Processing Data dengan Count Vectorizer

Untuk menggunakan count vectorizer, kita dapat memanggil fungsi ini dari library scikit-
learn. Fungsi yang akan kita panggil adalah CountVectorizer. Sebelum kita memanggil fungsi ini,
kita akan lebih dahulu memanggil fungsi train_test_split dari library sklearn.model_selection,
karena kita akan melakukan klasifikasi terhadap data yang memiliki label dan fitur. Kita akan
memasukkan kolom “Message” menjadi sebuah fitur (X) dan juga kolom “Category” sebagai
label (y).

Kita akan menggunakan 20% dari total keseluruhan data sebagai sebuah test data,
sedangkan 80% sisanya akan digunakan sebagai train data. Kita akan memisahkan keseluruhan
data train dan test menjadi masing - masing variabel X_train, X_test, y_train, dan y_test.
Setelah train data dan test data terbentuk, kita akan memanggil CountVectorizer dari
library sklearn.feature_extraction.text. Perhatikan gambar berikut ini.

Kita akan membuat sebuah variabel bernama count_vect yang akan memuat
CountVectorizer(). Dengan menggunakan CountVectorizer(), kita akan membentuk sebuah
Document Term Matrix (DTM) yang telah kita bahas sebelumnya pada bagian teori. Kita dapat
membandingkan ukuran dari X_train dengan X_train_counts yang merupakan DTM yang kita
buat dengan menggunakan CountVectorizer ini.

51
 Apabila kita membandingkan ukuran dari data X_train yang kita miliki, kita hanya
memiliki jumlah baris sebanyak 4.457 baris dan 1 kolom untuk X_train. Apabila kita mengecek
ukuran dari X_train_counts, maka sekarang jumlah kolomnya tidak lagi berjumlah 1.

Ketika kita melihat ukuran dari X_train_counts, sekarang ukuran kolomnya berubah
menjadi 7.701. Hal ini berarti ada 7.701 total kata yang berbeda dalam keseluruhan dokumen
X_train yang kita miliki. DTM akan memetakan masing - masing baris data pada tiap jumlah kata
yang berada didalamnya.

Melanjutkan Pre-Processing Data dengan TfidfTransformer

Setelah kita membentuk DTM, dengan menggunakan TfidfTransformer, kita akan

mengubah bobot dari masing - masing kata. Hal ini bertujuan untuk membuang kata - kata yang
sangat sering muncul, dan juga meningkatkan bobot untuk kata - kata yang jarang muncul dalam
dokumen tersebut. Untuk memanggil TfidfTransformer ini, kita akan memanggilnya dari library
sklearn.feature_extraction.text. Kita akan memasukkan fungsi TfidfTransformer ini pada
variabel tfidf_transformer, lalu akan memasukkan X_train_counts sebagai sebuah DTM
kedalamnya. Perhatikan gambar berikut ini.

52
 Karena TfidfTransformer ini hanya berfungsi untuk mengubah bobot dari tiap kata yang
berada dalam dokumen, maka apabila kita mengecek ukuran dari X_train_tfidf, ukuran dari data
tersebut akan sama dengan X_train_counts yang merupakan DTM kita.

(Opsi 2) Melakukan Pre-Processing Data dengan TF-IDF Vectorizer

Metode pengolahan fitur teks dengan menggunakan Count Vectorizer dan juga
TfidfTransform ini sangat umum untuk digunakan. Oleh karena itu, peneliti membuat sebuah
fungsi baru yang dapat kita panggil dari library sklearn.feature_extraction.text, yaitu
TfidfVectorizer. Fungsi TfidfVectorizer ini merupakan gabungan dari CountVectorizer dan juga
TfidfTransform sekaligus. Perhatikan penulisannya berikut ini.

Karena TfidfVectorizer ini merupakan gabungan dari kedua fungsi CountVectorizer dan
TfidfTransformer, maka ketika kita membentuk variabel X_train_tfidfvect sebagai hasil dari
fungsi ini, maka ukuran dari DTM yang terbentuk akan sama dengan X_train_tfidf yang
sebelumnya kita buat.

Ingat bahwa DTM akan membentuk tiap kata menjadi sebuah fitur dan juga akan
menghitung jumlah kemunculan kata tersebut pada tiap dokumen. Dengan demikian, DTM akan
memiliki tipe data numerik, yang dapat diolah dengan menggunakan algoritma Machine Learning.
Kita akan mencoba membuat sebuah model klasifikasi dengan menggunakan Support Vector
Classifier (SVC). Perhatikan sintaksnya berikut ini.

53
(Opsi 3) Menggunakan Pipeline untuk menggabungkan seluruh Proses

Metode Pipeline ini akan membuat sebuah jalur proses dalam pengerjaan model Machine
Learning. Pipeline ini dapat digunakan pada model Machine Learning apapun. Dengan
menggunakan pipeline, kita dapat mendefinisikan model kita bahwa kita menginginkan beberapa
proses tertentu sebelum pada akhirnya kita akan melakukan prediksi terhadap data yang kita miliki.
Pada pipeline yang akan kita buat ini, kita akan memberikan model TfidfVectorizer seperti yang
sudah kita lihat pada opsi 2 dan juga memberikan sebuah fungsi klasifikasi SVC yang juga telah
kita lihat pada opsi 2 secara bersamaan.

Kita akan memanggil fungsi Pipeline ini dari library sklearn.pipeline. Dengan Pipeline
ini, kita dapat menuliskan 2 proses yang akan kita kerjakan sebelum kita melakukan prediksi.
Proses pertama akan kita namakan ‘tfidf’ dimana pada proses ini kita akan memberikan fungsi
TfidfVectorizer() seperti yang telah kita bahas pada opsi 2, lalu kita memberikan proses kedua
yang akan kita namakan ‘clf’ dimana pada proses ini kita memberikan fungsi LinearSVC() sebagai
fungsi untuk klasifikasi.

54
Melakukan Prediksi dan Evaluasi Model

Setelah jalur pipeline yang menggambarkan proses yang kita inginkan telah terbentuk, kita
dapat menyimpan pipeline tersebut dalam sebuah variabel yaitu text_clf. Kita dapat memasukkan
data X_train dan y_train dalam pipeline tersebut dengan menggunakan fungsi .fit().
Ketika kita menggunakan fungsi .fit(), maka X_train dan y_train akan melewati kedua
proses yang ada pada pipeline tersebut. Kita ingat bahwa untuk melakukan evaluasi pada model
Machine Learning SVC, kita dapat menggunakan fungsi predict pada X_test. Karena sekarang
train data telah kita masukan pada model, maka kita bisa melakukan text_clf.predict(X_test)
untuk melakukan sebuah prediksi pada test data. Hasil prediksi ini dapat kita simpan pada variabel
prediction.

Setelah prediksi terbentuk, seperti yang kita lakukan pada model Supervised Learning, kita
akan mencoba untuk mengecek nilai akurasi, classification report, dan juga confusion matrix dari
hasil prediksi. Kita dapat memanggil ketiga fungsi tersebut dari library sklearn.metrics. Kita akan
mencoba untuk melihat hasil dari confusion matrix terlebih dahulu dan akan membandingkan hasil
prediksi dengan y_test.

Dari hasil confusion matrix yang terbentuk, kita lihat bahwa total False Positive dan False
Negative yang terbentuk totalnya adalah 9. Nilai ini sangat kecil sekali apabila dibandingkan
dengan keseluruhan data yang ada, 1.115 test data. Kita dapat mencoba untuk mengecek nilai
akurasi yang dihasilkan dari hasil prediksi tersebut.

55
 Nilai akurasi yang dihasilkan mencapai nilai 99%. Hal ini sangat bagus, mengingat bahwa
kita hanya memiliki 9 hasil prediksi yang salah dari model yang kita miliki. Untuk melihat laporan
dari hasil prediksi lebih jelas, kita dapat mencoba untuk menampilkan classification report.
Perhatikan gambar berikut ini.

Menguji Model dengan Data Baru

Dengan nilai akurasi yang tinggi, kita dapat memiliki sebuah ekspektasi bahwa ketika kita
memberikan sebuah teks baru kepada model, maka model yang kita buat dapat menentukan dengan
baik apakah teks tersebut berisikan sebuah pesan spam atau ham. Kita akan mencoba untuk
membuat sebuah teks baru dan memberikannya pada model kita. Teks yang akan kita berikan
adalah "Congratulation on winning the grand prize!". Apabila kita mengartikan teks tersebut,
teks tersebut tidak terkesan seperti sebuah spam, dan memiliki arti untuk menyelamati seseorang
yang memang memenangkan sesuatu. Apabila kita memberikan teks ini pada model, kita berharap
model tersebut akan mengeluarkan hasil yaitu ‘ham’. Perhatikan gambar berikut ini.

Perhatikan bahwa model kita berhasil untuk memprediksi kalimat tersebut sebagai sebuah
‘ham’. Sekarang kita akan mencoba untuk memberikan sebuah teks lain.

56
 Kita akan memberikan sebuah teks berikut ini : “Congratulations! You have been selected
as a winner! Free voucher for buying a car in our booth. Transfer the DP to this account
number 1234567890 until tomorrow evening to take on the promo. Grab it fast!”. Kalimat
tersebut sudah jelas berisikan sebuah spam, dimana kalimat tersebut dapat diberikan kepada
siapapun tanpa memandang orang yang menerima pesan tersebut, dan dapat dikirimkan berkali -
kali. Apabila kita memberikan teks ini pada model, maka kita berharap bahwa model akan
mengembalikan ‘spam’ untuk teks tersebut. Perhatikan gambar berikut ini.

Sesuai dengan perkiraan yang kita lakukan, bahwa model tersebut mengembalikan nilai
klasifikasi ‘spam’ untuk teks tersebut. Dengan demikian, kita telah yakin bahwa model yang kita
buat sebelumnya telah berhasil untuk melakukan prediksi terhadap klasifikasi sebuah teks
berdasarkan apakah teks tersebut sebuah spam atau bukan.

Sentiment Analysis
Sebelumnya, kita telah berhasil melakukan klasifikasi terhadap sebuah data teks dengan
menggunakan ekstraksi fitur dengan menggunakan library dari scikit-learn. Pada contoh
sebelumnya juga, kita melakukan klasifikasi terhadap sebuah data teks yang memiliki label spam
atau ham, dengan menggunakan salah satu metode Supervised Learning, yaitu Support Vector
Classifier. Akan tetapi, pada aplikasi sebenarnya, tidak banyak data berbentuk teks yang sudah
memiliki label yang sebelumnya telah ditentukan. Kita kemungkinan hanya memiliki data teks
tersebut. Secara sekilas, jenis data yang kita bicarakan adalah bagaimana cara kita mengolah data
yang berbentuk seperti data pada Unsupervised Learning?

57
 Sentiment Analysis merupakan salah satu studi pada NLP dimana kita dapat melihat
apakah emosi yang terpancar dari teks yang ada memiliki emosi positif, negatif, ataupun netral.
Umumnya, sentiment analysis ini digunakan untuk mengecek sebuah review dari sebuah produk,
apakah banyak orang yang menganggap produk tersebut baik atau tidak. Biasanya, apabila orang
menganggap bahwa produk tersebut baik dan bermanfaat, maka apabila mereka memberikan review
produk tersebut, isi emosi dari kata - kata yang terkandung dalam teks review tersebut akan
memiliki sebuah makna positif. Sebaliknya, apabila orang menganggap bahwa produk tersebut
tidak baik ataupun tidak bermanfaat untuk mereka, cenderung mereka akan memberikan sebuah
review yang tidak baik, dimana biasanya banyak berisikan kata - kata yang memiliki makna negatif.
Sentiment Analysis akan bertugas untuk mengecek apakah isi kalimat tersebut memiliki emosi
yang positif atau netral atau negatif.
Apabila kalian baru mendengar istilah mengenai sentiment analysis, biasanya apabila kalian
mencari tahu mengenai topik ini, jenis data yang dapat kalian temukan mungkin berbentuk seperti
berikut ini :

58
 Pada contoh tersebut, kita telah memiliki nilai sentiment dari teks yang ada. Apabila
demikian, maka sudah ada orang yang membaca teks tersebut lalu memberikan penilaian apakah
teks tersebut berisikan makna positif, netral, ataupun negatif. Mungkin juga bahwa ada orang yang
telah membuat sebuah algoritma model tertentu yang secara otomatis dapat menentukan apakah isi
teks tersebut memiliki sebuah emosi tertentu. Apabila kita telah memiliki nilai sentiment, maka apa
yang akan kita kerjakan mirip seperti yang telah kita bahas pada contoh pada Text Classification,
dimana kita sudah memiliki sebuah label. Nantinya pada contoh pada topik Sentiment Analysis ini,
kita akan mencoba bagaimana caranya kita membuat penilaian kita sendiri mengenai data review.

Konsep VADER

VADER (Valence Aware Dictionary for sEntiment Reasoning) merupakan sebuah model
yang telah dibuat untuk mengecek sentiment dari sebuah teks dan umum digunakan dalam
pengolahan data untuk Sentiment Analysis. Pada VADER ini, model ini sensitif terhadap polaritas
(positif/negatif) dan juga intensitas dari polaritas tersebut (kekuatan dari kata tersebut).
Sebagai contoh, beberapa kata seperti “love” atau “like” akan memiliki sentiment yang
bernilai positif, sedangkan kata seperti “did not love” akan memiliki sentiment yang bernilai
negatif. Walaupun pada kata “love” dan “did not love” sama - sama memiliki kata “love”
didalamnya, VADER dapat membedakan bahwa “love” akan memiliki makna positif sedangkan
“did not love” akan memiliki makna negatif. Hal ini yang dimaksud bahwa VADER sangat sensitif
terhadap polaritas tanda positif dan negatif dalam kalimat tersebut. VADER juga akan menilai
intensitas dari polaritas tersebut. Sebagai contoh, sebuah kata “I love the product.” dan “I really
LOVE IT!!!!” akan memiliki nilai intensitas yang berbeda. Walaupun kedua kata tersebut memiliki
makna positif, VADER akan mengembalikan sebuah nilai angka antara desimal, dimana apabila
semakin kuat, maka nilai tersebut akan mendekati angka 1. Pada kedua kata tersebut, VADER akan
membedakan tanda baca dan juga kapitalisasi kata, dan akan menyatakan bahwa pada kalimat
kedua akan memiliki intensitas sentiment positif yang lebih tinggi dibandingkan kalimat pertama.

59
 Walaupun library VADER yang akan kita gunakan ini sangat kuat untuk mendeteksi emosi
dalam sebuah teks, ada beberapa limitasi terhadap library ini. Yang pertama adalah dalam sebuah
data teks, terkadang ada orang yang menuliskan emosi positif dan negatif secara bersamaan dalam
sebuah teks. Sebagai contoh, teks berikut ini : “I already tried the folding phone product and
truly disappointed with how the folding part’s screen protector is easily fell off when I fold
the phone. But I’m aware that this is the first time you launch this product. Please do your
best to fixes the issue, cause I am one of your loyal customer and always bought your new
product in market. I’m waiting for your next updates for this folding phone!” memiliki
beberapa emosi yang bercampur didalamnya. Pada teks tersebut, orang tersebut mengungkapkan
kekecewaannya terhadap produk, namun tetap memberikan alasan positif dan juga sentiment positif
pada bagian akhirnya dengan memberikan pernyataan pelanggan setia dan juga semangat. Ketika
VADER menemukan teks seperti ini, VADER akan kesulitan untuk memberikan sebuah nilai pada
teks tersebut, karena emosi yang bercampur pada kalimat tersebut, sehingga hal ini dapat
menyebabkan nilai yang diberikan tidaklah akurat.
Permasalahan kedua yang sering terjadi apabila kita menggunakan VADER adalah, sulitnya
untuk mendeteksi emosi yang ada pada sebuah kata yang bersifat sarkasme. Sebagai manusia, kita
mengetahui bahwa sarkasme berisikan kata - kata yang bersifat untuk menyindir ataupun memiliki
makna negatif. Namun pada majas yang digunakan pada sarkasme, beberapa diantaranya tidak
menunjukkan kata - kata yang mencerminkan sentiment negatif didalamnya. Sebagai contoh,
VADER akan mendeteksi kata berikut memiliki sentiment yang positif : “You just broke my car
window. Great Job Andy!”. Perhatikan bahwa dalam kata tersebut, ada beberapa kata yang
menunjukkan sentiment positif seperti “Great Job”. VADER akan menilai hal ini sebagai sebuah
sentiment yang positif sehingga akan mengembalikan label positif untuk teks ini. Sedangkan
sebagai manusia, kita memahami bahwa arti dari kalimat tersebut adalah berupa sindiran terhadap
Andy yang telah memecahkan kaca mobil seseorang dan seharusnya memiliki sentiment negatif.
Hal ini yang akan sulit dideteksi oleh VADER.

60
 Kita akan mencoba untuk menggunakan VADER pada Python. VADER ini dapat kita
temukan sebagai sebuah fungsi dari library NLTK. Kita akan mencoba untuk membuat sebuah
proyek kecil untuk mengaplikasikan VADER ini dan mencoba untuk menentukan sentiment dari
teks yang kita miliki.

Studi Kasus : Review Aplikasi Pokemon Go pada Google Play Store - Part 1

Pada studi kasus ini, kita akan mencoba untuk mengambil data review yang dilakukan oleh
pengguna aplikasi dari salah satu permainan mobile apps yang cukup terkenal yang dirilis pada
tahun 2016 silam, yaitu Pokemon Go. Aplikasi ini terkenal karena menerapkan beberapa fitur
seperti AR dan juga beberapa fitur lainnya yang belum umum dirilis pada tahun 2016. Pada studi
kasus ini, kita akan mengambil seluruh komentar yang diberikan oleh pengguna game tersebut pada
Google Play Store, lalu kita akan mencoba mendeteksi sentiment dari review yang diberikan
dengan menggunakan Sentiment Analysis.

Menyiapkan File

Sebelum kita melakukan sebuah Sentiment Analysis, kita perlu mengambil dan membentuk
data - data yang diperlukan. Kita akan mengambil data review aplikasi Pokemon Go langsung dari
Google Play Store. Metode yang akan kita lakukan disebut dengan scraping, dimana metode ini
merupakan salah satu metode yang banyak digunakan oleh Data Engineer untuk mendapatkan data
publik dari website di Internet. Untuk melakukan scraping dari Google Play Store, ada library
khusus yang dibuat bernama google-play-scraper. Karena library ini khusus, kita perlu menginstal
library ini terlebih dahulu didalam Google Colab kita. Untuk menginstal library baru, kita akan
menggunakan perintah !pip install google-play-scraper.

61
 Kita juga dapat melihat contoh dan juga dokumentasi resmi dari library google-play-
scraper dalam link ini. Dalam dokumentasi tersebut, kita diberikan beberapa sintaks dan cara
untuk mengambil data dari Google Play Store. Untuk mengambil data dari sebuah aplikasi yang
ada pada Play Store, kita bisa mengambil id dari aplikasi tersebut. Id tersebut dapat kita temukan
pada link url dari aplikasi tersebut. Apabila kita membuka halaman aplikasi tersebut pada browser
internet kita, kita dapat melihat id tersebut pada bagian url.

ID dari tiap aplikasi dapat kita temukan setelah kata ‘id=’ pada link url tiap aplikasi. Selain
itu, kita bisa melihat keterangan lain seperti bahasa (hl=en) dan juga lokasi (gl=US) aplikasi
tersebut berada. ID ini akan kita butuhkan untuk dimasukkan menjadi sebuah variabel input pada
fungsi google-play-scraper yang nanti akan kita buat.
Sekarang kita akan mencoba untuk memanggil fungsi Sort dan reviews dari library google-
play-scraper yang kita sudah instal. Fungsi Sort ini akan mengurutkan informasi yang kita
dapatkan dari aplikasi, sedangkan fungsi reviews ini yang akan kita gunakan untuk mendapatkan
review dari Google Play Store. Selanjutnya, kita akan memberikan beberapa parameter pada fungsi
reviews yang digunakan untuk mengambil review dari Google Play Store.

62
 Kita akan membuat sebuah variabel bernama pages. Variabel ini akan berfungsi untuk
menghitung jumlah komentar yang kita ingin dapatkan. Dengan menuliskan jumlahnya adalah 500,
berarti akan ada 500 komentar yang kita ambil dari Google Play Store mengenai aplikasi
Pokemon Go ini. Kita juga akan memasukkan informasi seperti ID, bahasa, country, pages, dan
juga informasi Sort yang berfungsi untuk mengurutkan data kita. Seluruh data ini akan kita muat
dalam sebuah list yang bernama result. Karena berbentuk list, kita dapat mencoba untuk mengecek
salah satu data dengan menggunakan index. Berdasarkan dokumentasi, data hasil ini akan
ditampilkan pada index 0, sedangkan index 1 berisikan nomor halaman. Oleh karena itu, kita dapat
melihat data dengan menggunakan results[0], diikuti dengan index data yang kita inginkan.
Perhatikan contoh berikut untuk menampilkan salah satu data komentar pada index ke 10.

Ketika kita melihat hasil dari index ke 10, kita lihat bahwa data yang diperoleh berbentuk
seperti sebuah dictionary, dimana kita memiliki pasangan key dan juga value. Komentar berada
pada key ‘content’, sehingga key ini dapat kita panggil nanti untuk mengambil komentar.
Kita dapat membuat sebuah list baru untuk menampung seluruh komentar tersebut.
Perhatikan sintaks berikut ini.

Dengan menggunakan iterasi, kita akan mengambil seluruh komentar yang ada dalam 500
halaman yang kita buat sebelumnya. Selanjutnya, kita akan mencoba untuk melihat isi dari list
all_comments yang kita buat. Kita akan menggunakan library pandas untuk membuat sebuah
dataframe yang dapat menampung komentar tersebut.

63
 Ketika kita menjalankan sintaks tersebut, kita akan mendapatkan hasil berikut ini.

Setelah data tersebut siap dan sudah disimpan dalam sebuah dataframe, kita akan mencoba
untuk melakukan analisis terhadap data tersebut.

Membuat Model VADER

Kita akan membuat model VADER untuk melakukan analisa terhadap data komentar yang
telah kita dapatkan. Library yang digunakan adalah NLTK. Kita dapat mengetik import nltk dan
juga kita akan mendownload dataset vader_lexicon, yang kita gunakan sebagai basis untuk menilai
sentiment dari kalimat yang digunakan.

64
 NLTK menyediakan sebuah fungsi SentimentIntensityAnalyzer dari library
nlkt.sentiment.vader. Fungsi ini yang akan digunakan untuk menilai emosi dari kalimat yang ada.
Kita akan memasukkan fungsi ini dalam sebuah variabel sid.

Fungsi SentimentIntensityAnalyzer() akan menampilkan 4 informasi dalam bentuk

dictionary. Kita akan melihat key neg, neu, pos, dan compound yang mewakili nilai desimal dari
emosi yang dibaca oleh SentimentIntensityAnalyzer. Key compound ini akan berisi perhitungan
nilai gabungan dari total keseluruhan angka desimal neg, neu, dan pos. Kita akan mencoba sebuah
contoh untuk lebih memahami hasil dari output fungsi tersebut.

Sebuah teks yang dinilai tidak memiliki sebuah emosi positif ataupun negatif oleh
SentimentIntensityAnalyzer akan dianggap sebagai netral. Nilai desimal maksimal adalah 1,
sedangkan untuk nilai compound bisa bernilai dari -1 sampai 1. Apabila nilai intensitas dari teks
tersebut bersifat netral, maka nilai compound akan mendekati angka 0.

Ketika kita mengganti teks tersebut dengan sebuah kalimat yang memiliki beberapa emosi
positif, maka kita lihat bahwa nilai dari key pos akan meningkat. Nilai compound pun cenderung
untuk meningkat mendekati angka 1.

65
 VADER pun bisa mendeteksi emosi yang lebih kuat apabila menemukan kata - kata yang
mungkin memiliki makna lebih ataupun disertai dengan sebuah tanda baca seperti tanda seru (“!”).
Kita akan mencoba untuk membuat sebuah kata yang dikapitalisasi dan juga menggunakan tanda
seru.

Dapat kita lihat bahwa dengan kalimat yang memiliki kata - kata yang sama dengan
sebelumnya, apabila kita tambahkan kapitalisasi dan juga beberapa tanda baca diakhir untuk
penegas, maka nilai positif akan meningkat, dan juga nilai compound bertambah, menunjukkan
bahwa kalimat tersebut cenderung memiliki emosi positif yang kuat.

Kita juga dapat melihat apabila kita menuliskan kalimat yang negatif, maka nilai key “neg”
akan bertambah. Nilai compound yang dihasilkan pun bernilai negatif, menandakan bahwa kalimat
tersebut memiliki kecenderungan memiliki emosi yang negatif.
Setelah memahami bagaimana penggunaan fungsi SentimentIntensityAnalyzer tersebut,
kita akan mencoba untuk mengaplikasikan fungsi ini pada data komentar yang kita dapatkan
mengenai aplikasi Pokemon Go.

66
 Kita menggunakan fungsi lambda pada Python untuk mengaplikasikan fungsi pada
keseluruhan baris yang ada pada dataframe. Kita akan memberikan fungsi sid.polarity_score()
untuk menampilkan nilai sentiment dari tiap baris kalimat. Ketika kita menjalankan sintaks tersebut,
maka kita akan mendapatkan hasil berikut ini.

Kita hanya akan menggunakan nilai compound yang akan kita gunakan untuk menentukan
apakah komentar tersebut bernilai positif, negatif, atau netral. Kita dapat kembali menggunakan
fungsi lambda untuk mengambil nilai compound dari kolom scores.

Ketika kita menjalankan sintaks diatas, kita akan mendapatkan hasil berikut ini.

Kita mengetahui bahwa nilai compound akan mewakili emosi dari kalimat yang ada. Kita
akan membuat sebuah batas untuk menentukan nilai positif dan negatif. Pada kasus ini, kita akan
menganggap apabila nilai compound adalah 0 dan lebih dari 0, maka kita akan memberikan
sentiment Positive pada kalimat tersebut, sedangkan apabila nilai compound kurang dari 0, maka
kita akan memberikan sentiment Negative.

67
 Kita akan kembali menggunakan fungsi lambda untuk membuat sebuah teks bertuliskan
Positive apabila nilai compound bernilai lebih dari 0 dan selain nilai tersebut, kita akan
memberikan teks bertuliskan Negative. Kita akan membuat sebuah kolom bernama ‘sentiment’
untuk menampung nilai sentiment ini.

Terakhir, kita akan mencoba untuk merapihkan data tersebut, agar kita hanya melihat
kalimat dan juga nilai sentimentnya. Perhatikan sintaks berikut ini.

Ketika kita menjalankan sintaks tersebut, kita akan mendapatkan hasil berikut ini.

68
 Perlu kita ingat bahwa metode Sentiment Analysis ini mirip dengan Unsupervised
Learning pada materi Machine Learning, sehingga kita tidak akan mengetahui apakah model
VADER yang kita buat akurat atau tidak, hanya domain knowledge dari manusia yang dapat
menilai apakah hasil prediksi yang dilakukan VADER akurat atau tidak. Apabila kita melihat data
tersebut satu per satu, mungkin kita akan menemukan kalimat yang berisikan emosi positif, namun
dinilai sebagai sentiment negatif oleh VADER. Hal ini wajar karena memang pada bagian teori kita
sudah bahas sebelumnya bahwa apabila terdapat kalimat yang berisi emosi positif dan negatif
sekaligus, maka VADER akan kesulitan untuk memberi nilai, ataupun apabila ditemukan kata yang
bersifat sarkasme didalamnya.

Studi Kasus : Review Aplikasi Pokemon Go pada Google Play Store - Part 2

Pada Part 1, kita telah mencoba bagaimana caranya melakukan dan membuat nilai intensitas
emosi dari sebuah kalimat dengan menggunakan SentimentIntensityAnalyzer. Namun kita sulit
untuk menilai performa dari VADER tersebut, apakah model yang kita buat berhasil mendeteksi
emosi dari tiap kalimat adalah baik ataupun tidak. Apabila kita perhatikan ketika kita mengambil
data komentar dengan menggunakan library google-play-scraper, kita melihat bahwa kita
memiliki salah satu key bernama “score” dimana key ini akan berisi rating atau penilaian yang
diberikan oleh pengguna pada aplikasi Pokemon Go. Dalam aplikasi Sentiment Analysis,
metodologi ini cenderung digunakan untuk menilai sebuah review ataupun komentar terhadap
sebuah produk. Review yang didapatkan biasanya dapat berupa angka dan juga komentar yang
bersifat kualitatif. Walaupun mungkin nilai angka ini tidak akan akurat dan bernilai subjektif,
namun pada praktiknya nilai angka ini dapat kita gunakan sebagai patokan untuk menentukan
apakah model VADER yang kita buat akurat ataupun tidak. Kita akan mencoba untuk membuat
kembali model VADER dan mencoba mengambil kembali data yang akan kita gunakan dari
aplikasi Pokemon Go.

69
 Kita akan menggunakan fungsi Sort dan reviews yang sama seperti sebelumnya, dan kita
akan mengambil 500 data komentar. Seperti yang kita lakukan sebelumnya, dengan menggunakan
iterasi, kita akan menyimpan seluruh informasi komentar dan juga skor rating dalam variabel
all_comments dan all_ratings.

Kita akan membuat dataframe untuk mempermudah kita melihat data yang kita dapatkan
dari aplikasi. Kita akan memasukkan kedua variabel all_comments dan all_ratings tersebut
menjadi sebuah kolom dalam dataframe.

Ketika kita menjalankan sintaks diatas, kita akan mendapatkan sebuah dataframe berisikan
2 kolom yang berisi informasi komentar dan juga tiap skor ratingnya. Perhatikan gambar berikut
ini.

70
 Sama seperti pada langkah pada Part 1, kita akan membuat sebuah model VADER dan juga
mengaplikasikan model tersebut pada seluruh kalimat pada seluruh baris. Kita akan menggunakan
sintaks yang sama seperti pada Part 1.

Kita juga akan mengkonversi nilai skor rating menjadi sebuah sentiment. Karena
sebelumnya kita menggunakan kriteria dimana skor yang bernilai 0 dan positif akan menjadi
sentiment Positive, sedangkan sisanya akan kita anggap sentiment Negative, maka kita juga akan
menerapkan dimana skor yang bernilai 3 - 5 akan kita buat menjadi Positive, sedangkan 1 dan 2
akan kita anggap sebagai sentiment Negative. Perhatikan sintaks berikut.

Ketika kita menjalankan sintaks tersebut, maka kita akan mendapatkan hasil berikut ini.

71
 Perhatikan bahwa kita telah memiliki 2 kolom sentiment, dimana kolom sentiment ini
berasal dari nilai compound yang kita hitung dengan menggunakan
SentimentIntensityAnalyzer(), sedangkan rating_scores merupakan nilai konversi dari rating
angka menjadi rating review.
Untuk membandingkan kedua nilai ini, kita dapat menggunakan accuracy score,
classification report, dan juga confusion matrix untuk mengetahui nilai akurasi dan ketepatan
model kita. Kita akan mencoba untuk melihat nilai akurasi terlebih dahulu.

Dari hasil yang didapatkan kita mendapatkan nilai akurasi sebesar 71%. Nilai ini cukup
tinggi dimana berarti ada 355 data yang diprediksi sama oleh VADER. Kita akan melihat confusion
matrix untuk melihat berapa banyak data yang salah ditentukan oleh VADER.

Kita juga akan melihat hasil dari classification report dari data VADER dan juga data
rating.

Kita lihat bahwa nilai akurasi adalah 71% dan juga nilai presisi dan recall untuk tiap
kategori Negative dan Positive yang dihasilkan. Dengan model sederhana, nilai akurasi VADER
cukup baik.

72
Topic Modeling
Topic Modeling merupakan salah satu metode yang biasa digunakan dalam NLP untuk
membuat klasifikasi dari sebuah teks. Klasifikasi tersebut merupakan cara untuk menggolongkan
sebuah kalimat agar kalimat tersebut masuk dalam sebuah cluster atau kategori tertentu. Karena
sebagian besar data teks biasanya merupakan data yang tidak memiliki label, maka kita tidak akan
bisa menggunakan pendekatan metode Supervised Learning untuk membuat klasifikasi terhadap
data teks tersebut. Karena kita menggunakan data yang tidak memiliki label, maka kita bisa
mencoba untuk menemukan beberapa label baru. Kita akan membuat sebuah kelompok untuk
mengelompokkan beberapa data yang sama, yang memiliki sebuah topik yang sama. Karena
pendekatan yang dilakukan mirip dengan Unsupervised Learning, karena itu kita tidak bisa
menentukan apakah label topik yang kita buat benar atau salah. Label tersebut akan tergantung dari
domain knowledge yang diberikan oleh manusia.
Untuk membuat topic modeling ini, kita memiliki dua cara pendekatan yang dapat
dilakukan dan umum dilakukan, yang pertama adalah Latent Dirichlet Allocation (LDA) dan juga
Non-negative Matrix Factorization (NMF). Kita akan mencoba untuk membahas bagaimana cara
membuat topic modeling dengan menggunakan LDA terlebih dahulu.

Konsep Latent Dirichlet Allocation (LDA)

Konsep dari Latent Dirichlet Allocation (LDA) ini adalah menggunakan sebuah distribusi
peluang (probability distribution). Ketika kita membicarakan sebuah topik dalam sebuah teks,
umumnya kita menggunakan beberapa kata yang sama. Sebagai contoh, apabila kita menemukan
sebuah kalimat berbunyi demikian : “Banyak penjual bakmi yang memiliki enak berada di
Jakarta” ataupun kalimat lain yang berbunyi “Kalau kamu ingin beli nasi goreng, beli saja
dekat rumahku. Sudah murah, rasanya juga enak.” umumnya kita akan menemukan kata - kata
yang mirip. Kita mengetahui bahwa dalam kedua kalimat tersebut memiliki topik bahasan yang
sama dimana keduanya membahas mengenai kuliner ataupun makanan. Karena kita memiliki kata
“enak” pada kedua kalimat, LDA dapat mengkategorikan kedua teks tersebut pada grup yang sama.

73
 LDA umumnya akan menghitung jumlah dari kata yang digunakan pada sebuah kategori
tertentu yang banyak muncul pada suatu topik, lalu akan digunakan kembali untuk menilai
keseluruhan dokumen yang ada untuk menentukan bahwa sebuah teks masuk pada kategori topik
yang mana berdasarkan jumlah kata terbanyak dalam teks tersebut. Pada statistik, seluruh teks
tersebut merupakan probability distribution untuk tiap topik dimana topik tersebut merupakan
sebuah probability distribution untuk tiap kata.

Sebagai gambaran, pada sebuah teks ataupun dokumen, LDA akan membuat probability
distribution untuk beberapa kemungkinan kelompok topik yang mungkin terbentuk berdasarkan
kata - kata yang ada pada teks itu sendiri. Kita dapat memilih nilai probabilitas yang terbesar,
karena apabila probabilitas besar, maka jumlah kata yang masuk dalam topik tersebut semakin
banyak dalam teks tersebut.

Apabila kita mengecek isi dari salah satu topik tersebut, kita dapat melihat sebuah topik
akan berisikan kumpulan dari kata - kata. Apabila kita lihat pada gambar diatas, kita memiliki
probabilitas yang kecil untuk “he” dan “home” sedangkan kita memiliki probabilitas yang tinggi
untuk “cat” dan “dog” yang berarti kucing dan anjing. Kita dapat menyimpulkan bahwa topik
tersebut kemungkinan membahas mengenai hewan.

74
 Perlu diperhatikan bahwa kita tidak tahu apakah topik tersebut merupakan topik hewan atau
bukan, karena kita hanya melihat nilai probabilitas yang besar jatuh kepada kedua kata tersebut.
Untuk menentukan apakah topik tersebut benar membahas mengenai hewan, kita membutuhkan
bantuan manusia yang memiliki domain knowledge yang tepat pada kumpulan teks tersebut.
LDA akan mewakili dokumen sebagai sebuah kombinasi dari topik yang memiliki beberapa
kata yang memiliki beberapa probabilitas didalamnya. Untuk itu, penting bagi kita untuk
menentukan dahulu ada berapa banyak topik yang diinginkan untuk dibuat. Misalkan, untuk
menentukan apakah sebuah teks atau dokumen berisikan informasi mengenai makhluk hidup, kita
akan membutuhkan tiga kategori, yaitu untuk manusia, hewan dan tumbuhan. Informasi ini kita
dapatkan dari pengetahuan umum karena makhluk hidup di bumi hanya ada 3 jenis. Oleh karena
itu, untuk menentukan jumlah topik kita juga perlu memiliki pengetahuan khusus terhadap teks
yang kita miliki.
Pada awalnya LDA akan memasukkan kata - kata tersebut secara acak untuk tiap topik yang
kita tentukan. Untuk meningkatkan performa dari LDA, maka kita akan melakukan iterasi untuk
seluruh kata dalam seluruh teks yang kita miliki. Untuk tiap kata dalam tiap dokumen, kita akan
menghitung porsi dari kata tersebut dalam sebuah topik (jumlah kata tersebut dalam sebuah topik /
jumlah keseluruhan kata dalam seluruh dokumen). Selanjutnya kita juga akan melakukan iterasi
pada seluruh kata dalam sebuah topik tersebut untuk mengetahui probabilitasnya (jumlah porsi dari
kata tersebut / jumlah kata dalam topik tersebut). Kedua nilai probabilitas yang terbentuk akan
dikalikan, lalu kata tersebut akan kembali dimasukan dalam topik yang memiliki nilai probabilitas
yang dapat diterima. Pada akhirnya, kita akan memiliki topik yang berisikan kumpulan kata - kata
dengan nilai probabilitas yang mirip untuk dimasukan dalam topik yang sama. Kita akan
menggunakan topik tersebut sebagai patokan untuk melakukan kembali iterasi terhadap seluruh teks
yang kita miliki, lalu kita dapat mengelompokkan teks tersebut kedalam topik yang telah kita
tentukan sebelumnya. Kita juga dapat mencari tahu kata mana yang memiliki probabilitas terbesar
dalam topik tersebut.

75
 Kita akan mencoba untuk menggunakan metode LDA ini untuk menentukan topik dalam
studi kasus berikut ini.

Studi Kasus : Penggolongan Topik Untuk Data BBC News dengan Model LDA

Pada studi kasus kali ini, kita akan mencoba untuk membuat sebuah model yang dapat
mengelompokkan topik dari data berita yang didapat dari BBC News. Data yang kita gunakan
diambil dari referensi link berikut pada Kaggle. Kita akan membaca judul dan juga deskripsi berita,
lalu kita akan mencoba untuk menggolongkan topik dari tiap berita tersebut dengan menggunakan
metode LDA. Data tersebut dapat kita akses pada link berikut ini.

Menyiapkan File

Kita akan mencoba untuk membaca data file CSV dari link referensi yang sudah diberikan.
Kita akan membaca data tersebut dengan menggunakan pandas, lalu kita juga akan mengecek
apakah ada nilai Null pada data tersebut.

Ketika kita menjalankan sintaks diatas, kita akan menampilkan 5 data pertama.

Kolom title akan berisi judul dari berita yang diambil dari BBC News, sedangkan kolom
description akan berisi berita tersebut. Kita akan mengecek apakah ada baris yang memiliki nilai
Null atau tidak. Perhatikan sintaks berikut ini.

76
Membuat Model LDA
Karena setelah kita cek data kita tidak memiliki nilai Null, maka kita akan langsung untuk
membuat model LDA. Sebelum mulai membuat model LDA, kita terlebih dahulu akan
menggunakan Count Vectorization untuk membuat DTM.

Kali ini, kita akan menuliskan beberapa parameter yang akan digunakan pada fungsi
CountVectorizer kita. Parameter max_df merupakan jumlah maksimum document frequency, yang
artinya batas jumlah kata yang muncul. CountVectorizer akan mengabaikan kata yang muncul
dalam 90% dokumen kita. Parameter min_df merupakan kebalikan dari max_df, dimana paramater
ini akan mengabaikan kata yang muncul kurang dari 2 kali dalam seluruh dokumen. Kedua
parameter ini dapat kita tuliskan dalam bentuk persentase (dengan nilai desimal dibawah 1) ataupun
dengan jumlah (nilai integer) dokumen. Kita akan memberikan parameter stop_words yang adalah
“English”, dimana kita akan membuang seluruh stop words berbahasa inggris yang kita temukan
dalam dokumen dan tidak mengikutsertakannya dalam DTM. Setelah itu, kita akan memasukkan
kolom ‘description’ kedalam CountVectorizer yang kita buat.
DTM ini akan dibutuhkan sebagai sebuah fitur input pada LDA yang akan kita buat nanti.
Kita dapat mengambil fungsi LDA ini dari library scikit-learn, yaitu sklearn.decomposition,
dengan nama fungsinya adalah LatentDirichletAllocation. Perhatikan penulisan sintaks berikut
ini.

77
 Parameter penting yang perlu kita isikan pada fungsi LatentDirichletAllocation adalah
n_components, dimana parameter ini berfungsi untuk menentukan berapa banyak topik yang ingin
kita hasilkan. Kita akan menggunakan juga random_state untuk melakukan pengacakan pada
kondisi 42. Dengan menuliskan jumlah n_components = 6, maka kita akan membentuk 6 topik
bahasan. Kita akan memasukkan DTM kita pada model LDA yang kita buat untuk dilatih dan
diberikan nilai probabilitas untuk tiap katanya.

Seperti yang kita pelajari pada bagian teori, dimana model LDA ini akan memberikan nilai
probabilitas pada tiap kata. Untuk mengecek kata, kita dapat menggunakan salah satu tags dari
CountVectorizer yaitu cv.get_feature_names_out()[index] untuk mengeluarkan label dari kata.
LDA akan mengelompokkan kata - kata yang memiliki nilai probabilitas yang mirip, dimana kita
dapat mengeluarkan probabilitas untuk tiap topik dengan menggunakan LDA.components_[topik].

Ketika kita mengetikkan LDA.components_[0], kita akan melihat probabilitas dari seluruh
kata yang berada pada topik dengan index 0. Untuk melihat kata apa yang ada dalam topik tersebut,
kita bisa membuat semacam iterasi. Fungsi argsort() merupakan fungsi Python yang digunakan
untuk mengurutkan index berdasarkan nilai komponen yang terkecil ke terbesar. Dengan
menggunakan argsort dan indexing [-20:], maka kita akan memilih 20 nilai probabilitas terakhir,
dimana 20 nilai ini adalah nilai probabilitas terbesar.

78
 Karena variabel top_twenty_words ini berisikan nilai probabilitas dari 20 nilai terbesar
pada LDA.components_[0], maka dengan menggunakan cv.get_feature_names_out() kita bisa
mengambil index dari kata - kata tersebut. Ketika kita menjalankan sintaks diatas, kita akan
mendapatkan output berikut ini.

Dengan menggunakan konsep diatas, kita dapat mencoba untuk mengeluarkan seluruh kata
yang berada pada seluruh topik yang terbentuk. Kita akan mencoba untuk menggunakan iterasi
untuk melihat seluruh topik yang terbentuk, lalu dari tiap topik, kita akan mengeluarkan 15 kata
yang sering muncul atau mewakili topik tersebut. Perhatikan penulisan sintaksnya berikut ini.

79
 Ketika kita menjalankan sintaks diatas, kita akan mendapatkan hasil berikut ini.

Kita sudah mengeluarkan 15 kata dengan probabilitas terbesar dalam tiap topik. Pada topik
#0, dari kata - kata yang terbentuk, kita mungkin bisa menyimpulkan bahwa adanya peningkatan
harga yang dilakukan pemerintah. Pada topik #1, kita mungkin bisa menyimpulkan bahwa berisi
perang antara Rusia dan Ukraina. Pada topik #2, mungkin kita bisa menyimpulkan berisi topik
mengenai perang antara pemerintahan Rusia dan Ukraina. Pada topik #3, kita mungkin bisa
menyimpulkan adanya keterlibatan beberapa klub sepakbola. Pada topik #4, kita mungkin bisa
menyimpulkan adanya piala dunia dan kemenangan England. Pada topik #5, kita mungkin bisa
menyimpulkan percakapan dari raja dan ratu Inggris.
Kita tidak mengetahui apakah kesimpulan mengenai topik yang kita buat itu akurat atau
tidak, namun, tidak ada benar atau salah dalam melakukan pengelompokkan tersebut. Kita akan
mencoba untuk mengembalikan kategori topik tersebut dengan memasangkan topik dengan data
pada data asli kita. Untuk itu, kita akan menggunakan transform lalu memasukkan data tersebut
dalam variabel topic_results.

80
 Dengan menggunakan metode argmax(), kita akan menetapkan index dari topik yang
memiliki nilai terbesar, dalam kasus ini adalah nilai probabilitas yang terbesar dari tiap topik.

Kita bisa melihat keseluruhan data kita dengan menggunakan df.head().

Kita bisa melihat bahwa tiap kalimat pada ‘description’ akan diberikan masing - masing
topik yang memiliki nilai probabilitas tertinggi dengan menggunakan argmax(). Apabila kita lihat
sekilas, topik yang diberikan mewakili teks kalimat yang ada pada kolom ‘description’. Kita bisa
mengecek secara manual pada teks lainnya untuk mendapatkan keyakinan bahwa model LDA yang
kita buat berfungsi dengan baik.

Konsep Non-negative Matrix Factorization (NMF)

Non-negative Matrix Factorization adalah algoritma Unsupervised Learning yang

melakukan dimensionality reduction sekaligus melakukan clustering. Kita bisa menggunakan
NMF ini bersamaan dengan TF-IDF untuk membuat model yang akan membuat topik.
Konsep dasar dari NMF ini adalah membuat sebuah non-negative matrix (yang terbentuk
dari TF-IDF), lalu memetakan data tersebut menjadi perkalian dari 2 buah matriks vektor yang
memiliki ukuran yang sama. Perhatikan ilustrasi berikut ini.

81
 Sebuah DTM yang dihasilkan dari metode TF-IDF yang memiliki bobot (weight) dianggap
sebagai sebuah perkalian dari matriks weight (Document x Topic Matrix) dengan sebuah
terminologi (Topic x Term Matrix) dengan catatan nilai W dan H lebih dari 0. Nilai p pada topik
akan menunjukkan berapa banyak topik yang terbentuk, dan menjadi dimensi dari matriks weight.
Tiap anggota kata dalam topik tersebut adalah H. Dengan demikian, kita memiliki sejumlah input,
yaitu V dimana ini merupakan tabel TF-IDF yang merupakan non-negative matrix factorization,
lalu kita akan memberikan jumlah topik yang ingin diperoleh, yaitu p.
Ide matematika yang digunakan pada model ini adalah dengan melihat objective function,
yang merupakan sebuah pengukuran nilai error antara V dengan WH. Perhatikan rumusnya berikut
ini.

82
 Karena objective function ini merupakan nilai error dari V dan juga WH, maka tujuan kita
adalah untuk memaksimalkan optimisasi untuk meminimalisir nilai objective function. Cara umum
yang dilakukan adalah melakukan iterasi terhadap kedua W dan H untuk mendapatkan hasil yang
seimbang.

Sebagai kesimpulan, Weight dapat kita sebut juga sebagai Basic Vector, dan Hidden
Variables dapat kita sebut juga Coefficient Matrix. Basic Vector ini akan berisikan informasi
cluster (topik), sedangkan Coefficient Matrix ini akan berisikan kata - kata yang dapat dipetakan
pada topik. Selebihnya, proses yang kita lakukan sama dengan LDA, dimana kita akan memilih
jumlah topik yang kita inginkan, lalu kita juga perlu melakukan interpretasi sendiri terhadap topik
yang terbentuk dari kumpulan kata - kata tersebut. Kita akan mencoba untuk melakukan studi kasus
dengan menggunakan data BBC News yang sebelumnya kita gunakan untuk LDA.

Studi Kasus : Penggolongan Topik Untuk Data BBC News dengan Model NMF

Pada studi kasus kali ini, kita akan mencoba untuk membuat sebuah model yang dapat
mengelompokkan topik dari data berita yang didapat dari BBC News. Data yang kita gunakan
diambil dari referensi link berikut pada Kaggle. Kita akan membaca judul dan juga deskripsi berita,
lalu kita akan mencoba untuk menggolongkan topik dari tiap berita tersebut dengan menggunakan
metode LDA. Data tersebut dapat kita akses pada link berikut ini.

Menyiapkan File

Kita akan mencoba untuk membaca data file CSV dari link referensi yang sudah diberikan.
Kita akan membaca data tersebut dengan menggunakan pandas, lalu kita juga akan mengecek
apakah ada nilai Null pada data tersebut.
83
 Ketika kita menjalankan sintaks diatas, kita akan menampilkan 5 data pertama.

Kolom title akan berisi judul dari berita yang diambil dari BBC News, sedangkan kolom
description akan berisi berita tersebut. Kita akan mengecek apakah ada baris yang memiliki nilai
Null atau tidak. Perhatikan sintaks berikut ini.

Membuat Model NMF

Karena setelah kita cek data kita tidak memiliki nilai Null, maka kita akan langsung untuk
membuat model NMF. Sebelum mulai membuat model NMF, kita terlebih dahulu akan
menggunakan TFidfVectorizer untuk membuat DTM dengan bobot.

Kita akan memanggil fungsi TfidfVectorizer dari library sklearn.feature_extraction.text.

Kita dapat memasukkan fungsi ini pada variabel tfidf, lalu kita dapat memberikan parameter
max_df dan min_df dan juga stop words yang akan kita gunakan.

84
 Kita akan membentuk DTM dengan memasukkan data ‘description’ pada model tfidf kita.
Selanjutnya sama seperti pada model LDA, kita akan membuat model NMF dengan jumlah
komponen yang sama seperti yang kita buat pada model LDA sebelumnya. Kita akan memasukkan
model ini pada variabel nmf_model, lalu akan memasukkan DTM kita kedalam model ini.

Sama seperti Count Vectorization, kita bisa melihat nama fitur dari DTM yang terbentuk
oleh TF-IDF dengan menggunakan get_feature_names_out().

Sama juga dengan model LDA, kita dapat melihat probabilitas dari tiap kata yang terbentuk
dengan menggunakan model NMF dengan menuliskan nmf_model.components_[index].

Nilai probabilitas yang tertera adalah nilai probabilitas dari masing - masing kata dalam
topik tersebut. Kita akan mencoba untuk menampilkan 15 kata dari masing - masing topik.

85
 Ketika kita menjalankan sintaks tersebut, kita akan mendapatkan hasil seperti berikut ini.

Apabila kita bandingkan dengan topik yang kita dapatkan dengan menggunakan model
LDA, kita memiliki beberapa kata yang berbeda dan juga urutan model yang berbeda didalamnya.
Namun walaupun urutannya berbeda, kita akan tetap mendapatkan konteks topik yang sama dari
kelompok kata tersebut. Dari topik #0, kita mungkin bisa mengatakan bahwa topik tersebut
berbicara mengenai olahraga dan piala dunia 2022. Dari topik #1, kita mungkin bisa mengatakan
bahwa topik tersebut berbicara mengenai sebuah kejadian yang terjadi 7 hari terakhir. Dari topik #2,
kita mungkin bisa mengatakan bahwa topik tersebut berbicara mengenai biaya hidup orang di UK
yang diatur oleh pemerintah. Dari topik #3, kita mungkin bisa mengatakan bahwa topik tersebut
berbicara mengenai kemenangan klub sepakbola. Dari topik #4, kita mungkin bisa mengatakan
bahwa topik tersebut berbicara mengenai perang antara Rusia dan Ukraina. Dari topik #5, kita
mungkin bisa mengatakan bahwa topik tersebut berbicara mengenai pembunuhan seorang wanita.
Setelah kita mendapatkan gambaran mengenai topik - topik yang terbentuk, sama seperti
pada model LDA, kita akan mencoba untuk memetakan topik yang dihasilkan oleh model NMF ini
ke data asli kita. Kita akan melakukan transform terlebih dahulu untuk mengubah DTM menjadi
model NMF.

86
 Setelah kita melakukan transform, kita akan coba memetakan topik tersebut pada data asli
kita. Kita akan menggunakan fungsi argmax() untuk mencari nilai probabilitas tertinggi dari
seluruh topik untuk dipetakan pada data asli kita.

Kita bisa mengecek data asli kita dengan menuliskan df.head(). Perhatikan gambar berikut
ini.

Naive Bayes Theorem

Pada bagian kali ini, kita akan mencoba untuk membahas salah satu aplikasi dari
Supervised Learning untuk mengolah data berbentuk teks, yaitu dengan menggunakan teorema
Naive Bayes. Naive Bayes Theorem menggunakan teorema yang disebut dengan teorema Bayes
untuk melakukan klasifikasi pada model Supervised Learning.

Konsep Teorema Bayes

Teorema Bayes merupakan sebuah rumus probabilitas dimana kita menggunakan
probabilitas dari sebuah kejadian yang terjadi dengan melihat dari probabilitas dari kejadian
sebelumnya atau yang berhubungan dengan kejadian tersebut. Secara matematis, teorema Bayes
bisa dituliskan sebagai berikut :

87
 dimana :
A dan B = event/kejadian
P(A) = Probabilitas terjadinya event A
P(B) = Probabilitas terjadinya event B
P(A|B) = Probabilitas terjadinya event A apabila event B terjadi
P(B|A) = Probabilitas terjadinya event B apabila event A terjadi

Untuk memahami konsep dari rumus tersebut, mari kita perhatikan ilustrasi berikut ini.
Bayangkan dalam setiap gedung apartemen, kita memiliki sebuah sistem detektor alarm untuk
asap, yang digunakan untuk memadamkan api. Namun, kadangkala ada alarm yang berbunyi
ketika ada asap, namun tidak terjadi kebakaran besar (seperti contohnya asap ketika memasak
dengan oven).
Probabilitas yang mungkin terbentuk adalah :
- Probabilitas kebakaran besar terjadi hanyalah 1% dari seluruh kejadian.
- Alarm kebakaran tidak terlalu berfungsi dengan baik, dan probabilitas alarm nyala tiap 10%
dari seluruh kejadian.
- Ketika ada kebakaran besar, probabilitas alarm kebakaran akan berfungsi adalah 95%.

Pertanyaan yang dapat kita ajukan adalah, apabila ada alarm detektor asap
menyala, berapa probabilitas adanya kebakaran hebat yang terjadi?

Untuk menjawab pertanyaan ini, kita bisa menggunakan teorema Bayes. Kita perlu
membagi seluruh kejadian tersebut kedalam variabel yang tepat.
- Event A / P(A) : Kebakaran Besar
- Event B / P(B) : Alarm berfungsi
- P(A|B) : Probabilitas adanya kebakaran besar apabila alarm detektor berfungsi
- P(B|A) : Probabilitas bunyinya alarm detektor apabila adanya kebakaran besar.

88
 Apabila kita ingat bahwa kebakaran besar hanya terjadi sekitar 1%, sehingga kita bisa
mengatakan bahwa P(Kebakaran) akan bernilai 0,01. Kita ingat juga bahwa alarm kebakaran tidak
bekerja dengan baik dan probabilitasnya akan aktif adalah 10%, sehingga kita dapat mengatakan
bahwa P(Alarm) akan bernilai 0,1. Ketika ada kebakaran hebat yang benar terjadi, maka
probabilitas alarm akan menyala adalah 95%, sehingga kita bisa mengatakan bahwa P(Alarm|
Kebakaran) = 0,95. Berdasarkan teorema Bayes yang ada, kita bisa menggambarkan persamaan
tersebut sebagai berikut ini :

Kita akan memasukkan seluruh nilai variabel yang kita ketahui kedalam persamaan diatas,
maka kita akan memperoleh nilai berikut ini.

Dari kesimpulan perhitungan diatas, maka kita menyimpulkan apabila ada alarm detektor
kebakaran yang menyala, maka ada probabilitas sekitar 9,5% akan terjadi kebakaran hebat. Konsep
dari teorema Bayes ini yang menjadi dasar untuk kita menggunakan metode ini untuk melakukan
klasifikasi dari sebuah data teks dengan menggunakan Machine Learning.
Karena kita sudah memahami konsep dari teorema Bayes, maka kita akan mencoba melihat
bagaimana cara mengaplikasikan teorema ini untuk data berbentuk teks dan algoritma Machine
Learning. Kita bisa menganggap bahwa kita akan mencari probabilitas dari sebuah kelas
klasifikasi, dimana kita fitur yang diberikan telah terjadi atau benar adanya. Apabila kita
mengaplikasikan konsep ini pada teorema Bayes, maka kita bisa menganggap P(A) adalah
probabilitas dari terjadinya sebuah kelas klasifikasi, sedangkan P(B) merupakan probabilitas
terjadinya dari fitur - fitur. Kita dapat mengubah definisi tersebut menjadi rumus matematis.
Perhatikan rumus berikut ini.

89
 dimana :

Rumus tersebut didapatkan berdasarkan definisi yang kita bahas sebelumnya, dimana Ck
adalah kelas klasifikasi dan P(Ck) adalah peluang terjadinya. X merupakan kumpulan dari fitur
yang kita miliki untuk membentuk kelas tersebut. Kita dapat menyebutkan bahwa persamaan diatas
merupakan persamaan yang memiliki komponen X dan Ck didalamnya. Kita dapat menggunakan
chain rule untuk memecah persamaan tersebut menjadi beberapa komponen kecil. Perhatikan
gambar berikut ini.

Sebuah persamaan yang mengandung Ck dan X bisa kita tuliskan seperti gambar diatas,
yang memiliki arti fungsi p memiliki atribut X dimana X adalah x1, x2, …. xn, dan juga Ck. Rumus
tersebut dapat kita pecah seperti berikut ini

Karena bagian pembilang (numerator) akan selalu sama, maka kita bisa menuliskan fungsi
tersebut seperti berikut ini.

Karena pola dari teorema Bayes ini akan selalu berulang, maka kita bisa menuliskan
keseluruhan rumus tersebut seperti berikut ini.

90
 Dengan algoritma sepanjang itu, kita perlu membuat sebuah asumsi, bahwa seluruh nilai
fitur x adalah mutually independent, dimana seluruh fitur tersebut berbeda satu dengan yang
lainnya dan tidak memiliki korelasi. Hal ini mengapa teorema yang kita gunakan disebut sangat
naif (Naive Bayes Theorem), karena pada dasarnya sulit untuk menemukan fitur yang tidak
tergantung dengan fitur lainnya. Pada pemrosesan teks, sebuah kata umumnya akan memiliki arti
dan hubungan dengan kata sebelumnya, sehingga membuat asumsi ini sangat naif. Namun pada
praktiknya, penggunaan teorema ini dalam pemrograman memiliki performa yang oke dan tidak
buruk, sehingga kita bisa menggunakan teorema Naive Bayes untuk melakukan klasifikasi. Dengan
asumsi tersebut, maka rumus tersebut dapat kita ubah menjadi berikut ini.

Secara keseluruhan, seluruh gabungan dari persamaan tersebut akan membentuk persamaan
berikut ini :

Ada banyak model dari Naive Bayes yang ada, beberapa diantaranya adalah Multinomial
Naive Bayes, Gaussian Naive Bayes, Complement Naive Bayes, Bernoulli Naive Bayes,
Categorical Naive Bayes, dan lainnya. Dokumentasi mengenai model Naive Bayes yang tersedia
dapat dilihat disini.
Untuk Bab 7 - Natural Language Processing ini, kita hanya akan berfokus untuk
menggunakan Multinomial Naive Bayes saja, karena model ini yang juga umum dan sering
digunakan dalam pengaplikasian NLP. Kita akan membahas sedikit mengenai cara kerja
Multinomial Naive Bayes ini dalam pemrograman.

04 91
Konsep Multinomial Naive Bayes
Sebelumnya kita telah membahas konsep dari teorema Bayes. Pada bagian ini, kita akan
membahas mengenai konsep dan cara kerja dari salah satu model Machine Learning yang
menerapkan teorema Bayes, yaitu Multinomial Naive Bayes. Kita akan perhatikan ilustrasi berikut
untuk lebih memahami bagaimana cara kerja model tersebut.
Anggap kita memiliki sebuah data yang sudah dilakukan klasifikasi berdasarkan sentiment
analysis yang telah dilakukan (positif atau negatif). Dari 35 review film, kita memiliki 25 review
positif dan 10 review negatif.

25 review 10 review
p = 25/35 p = 10/35

Pada langkah berikutnya, kita akan mencoba untuk melakukan count vectorization pada tiap
kelas positif dan negatif yang terbentuk, dan setelah kita melakukan tahap tersebut, anggap kita
memiliki hasil berikut ini.

10 2 8 4 8 10 0 2

movie actor great film movie actor great film

Kita juga akan menghitung masing - masing probabilitas untuk tiap kata yang terbentuk dari
tiap kelas yang terbentuk.

P(movie|Pos) = 10/24 P(movie|Neg) = 8/20

P(actor|Pos) = 2/24 P(actor|Neg) = 10/20
P(great|Pos) = 8/24 P(great|Neg) = 0/20
P(film|Pos) = 4/24 P(film|Neg) = 2/20

92
 Sekarang perhatikan apabila kita memiliki sebuah kata review baru yang masuk, yaitu
“movie actor”. Review ini hanya berisikan 2 kata saja. Untuk menentukan apakah review ini akan
masuk dalam kategori positif atau negatif, kita akan mencoba mengecek keduanya. Berdasarkan
rumus yang kita dapat dari teorema Naive Bayes, maka kita akan mendapatkan nilai probabiltasnya
berikut ini :

“movie actor” “movie actor”

P(Pos) x P(movie|Pos) x P(actor|Pos) P(Neg) x P(movie|Neg) x P(actor|Neg)

25/35 x 10/24 x 2/24 10/35 x 8/20 x 10/20

P(pos|”movie actor”) ~ 0,024 P(neg|”movie actor”) ~ 0,057

Metode Naive Bayes ini akan memilih nilai probabilitas tertinggi dari yang dihasilkan tiap
kelas, sehingga dengan kata “movie actor”, maka Naive Bayes akan mengklasifikasikan kata
“movie actor” sebagai sentimen negatif.
Sekarang bayangkan apabila kita memiliki sebuah kata lain seperti “great movie”.
Berdasarkan kelas yang ada, probabilitas untuk kata “great movie” adalah sebagai berikut ini :

“great movie” “great movie”

P(Pos) x P(great|Pos) x P(movie|Pos) P(Neg) x P(great|Neg) x P(movie|Neg)

25/35 x 8/24 x 10/24 10/35 x 0/20 x 8/20

P(pos|”movie actor”) ~ 0,099 P(neg|”movie actor”) ~ 0

93
 Perhatikan bahwa pada sentimen negatif, nilai probabilitas dari kata “great” adalah 0.
Sehingga setiap kali muncul kata “great” pada data review baru, kita akan selalu mendapatkan nilai
probabilitas pada kelas negatif adalah 0. Hal ini akan membuat metode kita menjadi bias. Oleh
karena itu, salah satu teknik yang akan kita gunakan untuk menghindari hal ini adalah dengan
melakukan Alpha Smoothing. Alpha Smoothing ini akan mencegah agar probabilitas yang
dihasilkan tidak bernilai 0, dengan menambah jumlah kata yang ada dengan nilai tertentu. Sebagai
contoh ilustrasi, kita dapat menambah seluruh kata dengan 1, sehingga menjadi seperti berikut ini :

10 +1 2+1 8+1 4+1 8+1 10+1 0+1 2+1

movie actor great film movie actor great film

P(movie|Pos) = 11/28 P(movie|Neg) = 9/24

P(actor|Pos) = 3/28 P(actor|Neg) = 11/24
P(great|Pos) = 9/28 P(great|Neg) = 1/24
P(film|Pos) = 5/28 P(film|Neg) = 3/24

Sehingga ketika kita menghitung kembali “great movie”, maka kita akan mendapat nilai
berikut ini :

“great movie” “great movie”

P(Pos) x P(great|Pos) x P(movie|Pos) P(Neg) x P(great|Neg) x P(movie|Neg)

25/35 x 9/28 x 11/28 10/35 x 1/24 x 9/24

P(pos|”movie actor”) ~ 0,090 P(neg|”movie actor”) ~ 0,004

94
 Nilai dari sentimen negatif tersebut akan sangat kecil sekali apabila kita menggunakan
teknik Alpha Smoothing ini, namun kita menghindari adanya probabilitas bernilai 0. Namun untuk
menggunakan Alpha Smoothing ini, kita perlu berhati - hati dalam memberikan nilainya karena
apabila kita memberikan nilainya terlalu besar, maka dapat menyebabkan berkurangnya nilai
probabilitas dari kata - kata lain, yang dapat mengakibatkan adanya perubahan makna dan tingkat
probabilitas dari tiap kata lain yang terbentuk.

Studi Kasus : Melakukan Klasifikasi Data Sentimen dengan Naive Bayes

Setelah memahami bagaimana cara kerja dari metode Naive Bayes, kita akan mencoba
untuk melakukan prediksi terhadap data klasifikasi. Data klasifikasi yang kita akan gunakan
merupakan data lanjutan hasil pemrosesan Sentiment Analysis pada data aplikasi Pokemon Go
yang sebelumnya telah kita bahas pada bagian Sentiment Analysis sebelumnya. Karena kita sudah
pernah melihat bentuk datanya, maka pada studi kasus ini kita hanya akan melanjutkan pembuatan
sintaksnya dengan menggunakan sintaks yang sama untuk bagian Sentiment Analysis, lalu kita
akan lanjutkan untuk membuat sebuah model Naive Bayes untuk melakukan klasifikasi dengan
data yang baru.

Menyiapkan File

Karena kita sudah melihat seperti apa bentuk data review yang kita dapatkan dari Google
Play Store mengenai aplikasi Pokemon Go, dan bagaimana cara kita menentukan sentimen dari
tiap review tersebut, maka pada bagian ini kita akan menggabungkan seluruh sintaks yang
digunakan menjadi 1. Kita hanya akan berfokus untuk menggunakan Naive Bayes untuk
melakukan pelatihan model untuk melakukan klasifikasi terhadap data baru nantinya. Perhatikan
sintaks berikut yang digunakan untuk mendapatkan data review Pokemon Go dari Google Play
Store dengan menggunakan library Google-Play-Scraper, dan juga bagaimana kita menentukan
sentimen tiap review tersebut.

95
 Kita akan menginstal library google-play-scraper yang kita gunakan terlebih dahulu.
Setelah itu, kita akan menuliskan ulang sintaks yang kita gunakan untuk membuat model
Sentiment Analysis dalam sebuah sel kode.

Ketika kita telah menjalankan sintaks diatas, kita akan melihat bentuk dari dataframe df.
Kita bisa menggunakan df.head() untuk melihat bentuk dataframe kita.

96
Melakukan Pre-Processing Data

Setelah kita mendapatkan seluruh data review, kita akan memisahkan data tersebut menjadi
sebuah fitur dan label. Kita akan menggunakan kolom “comments” sebagai fitur, dan kolom
“sentiment” sebagai label.

Setelah kita membagi data tersebut menjadi fitur dan label, sekarang kita akan
menggunakan fungsi train_test_split untuk membagi data kita menjadi train data dan juga test
data. Kita akan menggunakan 80% data sebagai train data dan 20% data digunakan untuk test data.
Perhatikan sintaksnya berikut ini.

Ingat bahwa ketika kita menggunakan teorema Naive Bayes, kita akan memberikan bobot
pada tiap kata - kata pada tiap klasifikasi. Oleh karena itu, kita akan membuat sebuah DTM dengan
menggunakan count vectorization terlebih dahulu. Perhatikan sintaksnya berikut ini.

97
 Kita akan menggunakan parameter stop_words = ‘english’, dan ini akan membuang
seluruh kata - kata yang dianggap sebagai sebuah stop words. Kita juga akan memasukkan X_train
kedalam count vectorizer, menjadi X_train_tfidf. Kita juga akan memasukkan X_test kedalam
count vectorizer ini, menjadi X_test_tfidf.

Membuat Beberapa Model Klasifikasi

Untuk membandingkan performa model, kita akan mencoba untuk membuat beberapa
model klasifikasi yang kita kenal, yaitu dengan menggunakan Logistic Regression, Support
Vector Classifier, dan juga Linear SVC.

Dengan menggunakan Logistic Regression, kita hanya akan membatasi model tersebut
untuk melakukan 1000 iterasi saja. Kita akan memasukkan X_train_tfidf dan juga y_train
kedalam model untuk dilatih.

Dengan menggunakan Support Vector Classifier, kita akan menggunakan kernel ‘rbf’
yaitu Radio-Based Frequency, yang memiliki performa terbaik dalam Support Vector Classifier.
Kita juga akan memasukkan X_train_tfidf dan juga y_train kedalam model untuk dilatih.

98
 Kita juga akan mencoba model LinearSVC, yaitu model Support Vector Classifier yang
menggunakan kernel ‘linear’. Kita akan memasukkan X_train_tfidf dan juga y_train kedalam
model ini.

Mengecek Performa dan Evaluasi Tiap Model

Kita akan mencoba mengecek performa dari ketiga model yang telah kita buat. Untuk
memudahkan pengecekan, kita akan membuat sebuah fungsi yang dapat menampung hasil prediksi
dan juga menampilkan hasil dari performa model tersebut. Perhatikan sintaksnya berikut ini.

Disini kita menggunakan fungsi warnings dari library warnings untuk menghapus seluruh
peringatan yang mungkin muncul ketika kita menjalankan sintaks kita. Apabila kita tidak
menghapus seluruh peringatan, maka ketika kita menggunakan print(), kita akan melihat banyak
peringatan. Peringatan ini dapat muncul apabila kita tidak menemukan sebuah kata dalam train
data ketika kita akan melakukan evaluasi terhadap test data. Ini akan mengakibatkan nilai
probabilitas mengeluarkan nilai 0 dan akan memunculkan sebuah peringatan. Walaupun ada
peringatan, ini tidak akan menghentikan program kita, namun ada baiknya untuk menghapus
peringatan tersebut agar kita mendapatkan hasil keluaran yang lebih bersih. Selebihnya, kita akan
menggunakan fungsi predict() untuk prediksi dan mengecek performa dengan classification report
dan confusion matrix.

99
 Kita akan mencoba untuk menampilkan hasil performa dari masing - masing model. Kita
akan melihat hasil dari Logistic Regression terlebih dahulu.

Ketika kita melihat performa dari Logistic Regression, kita lihat bahwa model kita gagal
untuk memprediksi kelas negatif, karena kita dapat lihat bahwa nilai presisi dari sentimen negatif
adalah 0. Akurasi senilai 73% didapatkan karena model tersebut memprediksi 73 data yang
memiliki sentimen positif dengan benar. Walaupun nilai performa bagus, berada di angka 73%,
namun apabila kita menggunakan model ini, kita kemungkinan akan mendapatkan hasil klasifikasi
yang bias dan tidak tepat.

100
 Kita juga akan melihat performa dari menggunakan model SVC dengan kernel ‘rbf’. Ketika
kita lihat hasilnya, model tersebut memiliki performa yang sama dengan model Logistic
Regression, dimana kita mendapatkan akurasi senilai 73%, dimana akurasi ini didapatkan dari hasil
73 data positif yang benar diprediksi dan 0 data negatif yang diprediksi. Kita akan mencoba melihat
hasil performa dari menggunakan model LinearSVC.

Ketika kita melihat performa dari model LinearSVC, kita lihat nilai akurasi hanya 72%,
lebih rendah dibandingkan dengan kedua model sebelumnya yang memiliki nilai akurasi 73%.
Namun pada model LinearSVC ini, kita memiliki nilai presisi yang bervariasi dimana kita
memiliki nilai presisi untuk positif sebesar 76% dan negatif sebesar 47%. Kita dapat melihat bahwa
LinearSVC memiliki performa yang lebih baik dimana model ini dapat membedakan sentimen
positif dan negatif dengan baik dibandingkan dengan kedua model sebelumnya.

101
Deep Learning untuk NLP
Kita telah membahas konsep dari Deep Learning pada materi Bab 4E - Deep Learning.
Deep Learning umumnya cocok untuk digunakan untuk memproses data yang memiliki jumlah
atau ukuran yang besar, sehingga cocok untuk digunakan untuk melakukan pemrosesan data berupa
teks seperti yang kita bahas di Bab ini.
Kita mengetahui beberapa metode Deep Learning yang umum digunakan, yaitu ANN
dimana merupakan artificial neural network yang umum digunakan, lalu kita juga memiliki CNN
yang merupakan convolutional neural network yang digunakan untuk pemrosesan gambar. Kita
juga memiliki model RNN yang merupakan recurring neural network untuk melakukan
pemrosesan yang memperhatikan sebuah urutan. Kita juga memiliki beberapa metode lain seperti
Autoencoder dan juga GAN yang juga merupakan bagian dari Deep Learning. Namun dari
seluruh metode yang kita kenal ini, apakah ada metode yang cocok untuk digunakan untuk
pemrosesan teks menggunakan Deep Learning?

102
 Apabila kita melihat sekilas mengenai penggunaan dari beberapa metode neural network
yang ada, kita melihat bahwa metode RNN yang paling cocok dan mendekati untuk melakukan
pemrosesan terhadap data teks. Kita akan membahas ulang sedikit mengenai metode RNN ini untuk
mengetahui bagaimana konsep yang dapat digunakan oleh RNN untuk melakukan pemrosesan data
teks ini.

Recurrent Neural Network (RNN)

Seperti yang telah kita jelaskan pada Bab 4E - Deep Learning, kita membahas salah satu
metode neural network yang ada, yaitu Recurrent Neural Network (RNN). RNN dapat kita
gunakan apabila kita memiliki data yang membutuhkan urutan. Beberapa contoh data yang
berurutan diantaranya adalah : Time-Series Data (Penjualan, tren, dan lainnya), kalimat, audio,
musik, dan jenis data lainnya yang membutuhkan urutan.
Kita akan membahas sedikit ilustrasi dari data yang berurutan tersebut. Misalkan kita
memiliki sebuah data x = [1, 2, 3, 4, 5, 6]. Dengan data tersebut, kita berharap bahwa RNN dapat
melakukan prediksi angka berikutnya, yaitu 7. Apabila kita menambahkan data prediksi tersebut
dalam data asli kita x = [1, 2, 3, 4, 5, 6, 7], kita juga akan berharap bahwa RNN dapat menebak
urutan berikutnya yaitu 8.
Pada metode neural network lainnya yang telah kita ketahui, kita bahwa umumnya input
akan dimasukkan dalam neuron untuk menghasilkan sebuah output. Namun pada RNN, output itu
akan dikembalikan menjadi input bagi proses selanjutnya, sehingga akan tercipta konsep seperti
berikut ini.

Time
Output Output Output Output
t-1 t t+1

Input Input Input Input

t-1 t t+1
103
 Sebuah sel yang merupakan sebuah fungsi input dari proses sebelumnya disebut juga
sebagai sebuah memory cells (sel memori). Kita juga memiliki beberapa variasi mengenai
bagaimana bentuk dari sel memori ini berdasarkan proses input dan outputnya, beberapa
diantaranya adalah sebagai berikut ini :

Penjelasan lebih lengkap dapat kita pelajari pada Bab Deep Learning. Berikutnya kita juga
akan membahas sedikit mengenai LSTM, dimana struktur ini akan berperan penting mengenai
bagaimana caranya kita akan mengekstrak data berbentuk teks dan menghasilkan kembali sebuah
teks.

Long Short-Term Memory (LSTM)

Sebuah masalah yang terjadi pada model RNN adalah neuron yang kita miliki cenderung
akan “melupakan” input yang pertama kali diterima, karena setiap kali kita akan memberikan
informasi baru yang merupakan output dari proses sebelumnya, akan ada sebagian informasi yang
hilang pada tiap proses. Kita membutuhkan semacam memori yang dapat menampung data lebih
banyak agar neuron tidak melupakan input kita yang pertama kali.
Long Short-Term Memory (LSTM) merupakan memori yang dibuat untuk menangani
permasalahan ini. Kita akan melihat sedikit konsep dari LSTM berikut ini.

Ht
New Long-
Long-Term Term Memory
Forget Output
Memory Gate Gate

New Short-
Short-Term Input Gate
Update
Gate Term Memory
Memory

Xt
104
 Dalam sebuah LSTM, ada 4 gerbang (gate) yang memiliki peran tertentu. Kita akan
membahas proses yang pertama, yaitu forget gate. Pada forget gate, kita akan menentukan
informasi apa yang akan “dilupakan” oleh LSTM. Kita dapat melihat rumus matematis dari gerbang
ini.
ht

+ Ct
Ct-1 x
tanh

X
ft X
It Ct

ht-1
σ σ tanh σ
ht

Xt

Kita akan memasukkan input, yaitu Xt dan juga memori jangka pendek (ht-1) kedalam
sebuah fungsi sigmoid. Biasanya nilai input Xt sudah dinormalisasi sehingga hanya akan bernilai
antara rentang 0 dan 1. Karena kita menggunakan fungsi sigmoid, maka hasil output ft hanya akan
berupa rentang 0 dan 1, dimana output yang bernilai 0 akan “dilupakan” sedangkan yang bernilai 1
akan “disimpan”. Apabila kita aplikasikan ini dalam data teks, LSTM ini akan mengingat informasi
mengenai sebuah subjek dalam kalimat, agar ketika ada kalimat berikutnya yang berhubungan
dengan subjek tersebut, maka RNN dapat mengingat siapa subjek tersebut dan dapat memberikan
kata panggil orang ketiga (he / she / it) pada subjek tersebut. Informasi lainnya yang mungkin tidak
dibutuhkan untuk pembentukan teks selanjutnya akan dihilangkan oleh LSTM.
Pada proses kedua, kita akan membahas mengenai input gate. Pada proses ini, kita akan
menentukan informasi baru apa yang akan kita “ingat” pada model. Kita dapat melihat rumus
matematis dari gerbang ini.

105
 ht

+ Ct
Ct-1 x
tanh

X
ft X
It Ct

ht-1
σ σ tanh σ
ht

Xt

Kita akan mengambil kedua input Xt dan juga ht-1 sebagai It yang merupakan fungsi input
gate, dan juga Ct yang merupakan kumpulan dari informasi data yang mungkin akan menjadi
kandidat “informasi baru” yang akan diingat oleh LSTM. Karena kita menggunakan fungsi sigmoid
kembali untuk It, maka kita akan mendapatkan kumpulan nilai dengan rentang 0 dan 1. Fungsi
tangen hiperbolik akan membentuk sebuah vektor dengan nilai antara rentang -1 sampai 1 yang
menentukan data - data yang akan jadi kandidat “informasi baru”. Kedua fungsi It dan Ct ini akan
kita gabungkan lalu akan digunakan untuk memperbarui informasi yang ada dalam LSTM. Aplikasi
gerbang ini dalam data berbentuk teks adalah, apabila kita memiliki subjek baru dalam kalimat
yang akan kita analisa, maka LSTM cenderung akan membedakan informasi dari kedua subjek
yang kita miliki. Sebagai contoh, LSTM akan dapat membedakan jenis kelamin dari kedua subjek
yang telah kita sebutkan dari data teks (apabila disebutkan pada teks) atau akan menggantikan
informasi jenis kelamin sebelumnya (apabila pada proses sebelumnya LSTM telah menentukan
jenis kelaminnya namun terdapat informasi baru yang salah diprediksi oleh LSTM).
Proses berikutnya kita akan membahas mengenai update gate. Proses ini akan memperbarui
informasi yang disimpan dalam LSTM dengan fungsi ft, It, dan Ct yang kita miliki sebelumnya,
untuk dibentuk sebuah fungsi Ct baru yang dapat diberikan pada proses selanjutnya nantinya. Kita
dapat melihat rumus matematis dari gerbang ini.

106
 ht

+ Ct
Ct-1 x
tanh

X
ft It Ct X

ht-1
σ σ tanh σ
ht

Xt

Fungsi update gate (Ct) ini hanya akan mengambil informasi ft yang akan kita kalikan
dengan fungsi long-term memory dari proses sebelumnya, guna untuk memperkuat informasi long-
term memory sebelumnya dan menentukan apakah informasi tersebut masih layak untuk disimpan
atau dapat kita lupakan. Kita juga akan menambah informasi tersebut dengan kandidat “informasi
baru” yang kita dapatkan dari hasil keluaran input gate dengan mengkalikan “informasi baru”
tersebut dengan nilai fungsi sigmoid dari “informasi baru” tersebut. Hasilnya akan membentuk
sebuah fungsi Ct yang akan kita gunakan sebagai long-term memory baru untuk proses selanjutnya
nantinya. Aplikasi gerbang ini untuk data berbentuk teks adalah, ada kemungkinan bahwa model
LSTM salah untuk menentukan jenis kelamin dari salah satu subjek yang telah muncul pada sebuah
kalimat. Dengan adanya gerbang ini, maka LSTM dapat memperbaiki informasi tersebut dan
nantinya dapat mengembalikan informasi subjek tersebut dengan benar. Aplikasi lainnya apabila
terdapat informasi baru mengenai subjek tersebut, maka LSTM dapat menambahkan informasi
tersebut dalam sel memorinya.
Kita akan membahas proses selanjutnya yang merupakan proses terakhir, yaitu output gate.
Proses terakhir ini sangat sederhana, dimana pada proses ini kita hanya akan membuat sebuah filter
untuk menentukan informasi mana yang akan kita tampilkan dari proses pada periode tersebut. Kita
akan melihat rumus matematis dari gerbang tersebut.

107
 ht

+ Ct
Ct-1 x
tanh

X
ft X
It Ct

ht-1
σ σ tanh σ
ht

Xt

Pada output gate, kita akan mengambil informasi dari hasil long-term memory yang telah
kita buat dengan menggunakan update gate sebelumnya yang akan kita kalikan dengan nilai
tangent hiperbolik untuk membuat rentang data menjadi -1 sampai 1, yang kita bandingkan dengan
fungsi sigmoid untuk menentukan apakah informasi tersebut akan kita keluarkan sebagai hasil pada
proses periode tersebut atau tidak. Dengan nilai fungsi sigmoid adalah rentang 0 dan 1, maka kita
bisa membuat semacam filter untuk menentukan informasi yang dapat dikeluarkan pada periode
tersebut. Aplikasi dari gerbang ini dalam data berbentuk teks adalah kita dapat menentukan urutan
kata ataupun kalimat yang akan muncul setelah ini ketika kita menyebutkan kedua subjek yang
telah kita bahas sebelumnya, mungkin kita dapat membahas mengenai kemiripan dari kedua subjek
ini terlebih dahulu, ataupun menyebutkan informasi lainnya mengenai kedua subjek tersebut
ataupun mungkin dapat membandingkan keduanya.
Kita juga memiliki beberapa variasi dari LSTM dengan model lainnya, salah satunya adalah
Peepholes LTSM. Pada variasi model ini, kita dapat membandingkan informasi long-term memory
dari proses sebelumnya dengan long-term memory yang kita perbarui pada proses sekarang, untuk
menentukan hasil dari output gate. Kita dapat melihat rumus matematisnya berikut ini.

108
 Pada Peepholes LSTM diatas, Kita akan mengambil informasi dari long-term memory
sebelumnya yang akan kita jadikan input sekaligus untuk forget gate, untuk menentukan apakah
informasi dari long-term memory tersebut masih layak untuk disimpan atau tidak. Selain itu, long-
term memory yang lama ini juga akan kita berikan sebagai input untuk input gate untuk
dibandingkan dengan kandidat “informasi baru” lainnya. Kita juga akan mengambil hasil dari
keluaran update gate yang merupakan gabungan dari forget gate dan input gate, menjadi input
untuk menentukan output gate dengan membandingkan informasi tambahan (long-term memory
lama) tersebut apakah layak untuk dijadikan output untuk output gate atau tidak.

Model diatas merupakan salah satu bentuk LSTM lainnya yang cukup terkenal, dikenal
dengan nama Gate Recurrent Unit (GRU). Model LSTM diatas lebih sederhana dibandingkan
model LSTM pada umumnya, dimana output gate dan update gate dijadikan satu. Model ini
muncul sejak tahun 2014, dan menjadi populer sampai sekarang karena lebih sederhana. Kita akan
mencoba untuk menggunakan Keras untuk mengolah data teks dan mencoba untuk membentuk
sebuah data teks baru dengan menggunakan LSTM.

109
Studi Kasus : Membuat Text Generator dengan Neural Networks dan LSTM

Kita akan mencoba aplikasi dari text generator dengan menggunakan Neural Network dan
LSTM. Text Generator adalah salah satu aplikasi dari penerapan Deep Learning pada NLP,
dimana kita menggunakan LSTM untuk menghasilkan sebuah teks baru berdasarkan teks yang kita
miliki yang kita gunakan untuk melatih model Deep Learning. Kita akan mencoba untuk
memberikan model kita sebuah data berbentuk teks, yaitu skrip naskah Shakespeare yang dikemas
dalam bentuk file .txt. Percobaan ini akan kita lakukan dengan mengambil referensi sintaks dan
juga dokumentasi resmi dari library Tensorflow berikut ini.

Menyiapkan File

Untuk mendapatkan file berisi naskah Shakespeare tersebut, kita akan mendapatkan data
tersebut dari dataset contoh yang telah tersedia pada library Tensorflow.

Kita akan mengambil file tersebut melalui dataset yang ada pada Google dengan
mengetikkan file yang kita inginkan, lalu lokasi file tersebut '
https://storage.googleapis.com/download.tensorflow.org/data/shakespeare.txt' dengan
menggunakan fungsi tf.keras.utils.get_file(). File tersebut akan berbentuk sebuah .txt, sehingga
kita bisa membaca file tersebut dengan menggunakan fungsi open() pada Python. Kita akan
membaca data tersebut dalam bentuk unicode dengan menuliskan mode ‘rb’, sehingga apabila kita
ingin menampilkan file tersebut kembali ke dalam bentuk yang dapat kita mengerti, kita akan
menggunakan decode() dengan format ‘utf-8’. Kita dapat mengecek panjang dari teks tersebut
dengan menggunakan len(). Perhatikan hasilnya berikut ini.

110
 Kita lihat bahwa panjang dari karakter tersebut adalah 1.115.394. Karakter tersebut
merupakan jumlah karakter (bukan kata) yang ada dalam teks tersebut. Kita bisa mencoba untuk
melihat isi dari 250 karakter pertama yang ada pada file tersebut dengan menggunakan indexing.
Perhatikan sintaks berikut ini.

Perhatikan bahwa bentuk dari teks tersebut merupakan percakapan dalam naskah
Shakespeare. Kita dapat melihat subjek dan juga masing - masing percakapannya. Kita juga akan
mencoba untuk melihat karakter apa saja yang ada dalam seluruh teks tersebut.

Ketika kita menjalankan sintaks diatas, kita dapat akan melihat seluruh karakter unik yang
berada pada teks tersebut dan karakter tersebut sudah diurutkan oleh Python. Variabel vocab akan
berbentuk sebuah list. Perhatikan outputnya berikut ini.

111
 Apabila kita mengecek jumlah karakter unik dalam variabel vocab tersebut, kita akan
melihat keseluruhannya adalah 65 karakter unik.

Pre-Processing Data - Vectorize Text (Contoh)

Sebelum kita membentuk model dan melakukan pelatihan terhadap model kita, ada
beberapa hal yang perlu kita lakukan terlebih dahulu. Kita mengetahui bahwa neural network
menggunakan beberapa perhitungan matematis, sehingga kita tidak bisa memberikan input sebuah
data berbentuk teks untuk diolah oleh neural network. Kita perlu mengubah teks tersebut menjadi
sebuah angka dahulu agar dapat diolah. Proses untuk mengubah teks ini menjadi angka adalah
vektorisasi (vectorize), dimana kita akan memetakan masing - masing karakter menjadi index.
Untuk lebih memahami prosesnya, kita akan mencoba melihat contoh berikut ini.

Kita akan mencoba menggunakan beberapa kata asal untuk memahami bagaimana cara
mengubah teks menjadi angka. Kita akan memiliki 2 kata, yaitu ‘abcdefg’ dan ‘xyz’. Kita akan
mengubah teks tersebut menjadi bentuk unicode terlebih dahulu dengan menggunakan fungsi
tf.strings.unicode_split dari Tensorflow. Perhatikan gambar diatas. Ketika sudah berubah menjadi
unicode, maka tiap karakter dalam teks tersebut akan diberikan imbuhan ‘b’ didepan teks tersebut,
menandakan bentuknya yang sekarang merupakan data biner.

112
 Kita juga akan menggunakan fungsi StringLookup dari Tensorflow, yaitu
tf.keras.layers.StringLookup() yang akan mencocokan kata tersebut dengan kumpulan kamus
index karakter yang kita miliki. Perhatikan sintaksnya berikut ini.

Ketika kita melihat hasilnya, kita akan melihat beberapa angka dalam list tersebut. Angka
tersebut mewakili karakter yang sebelumnya ada pada dalam list vocab yang kita bentuk
sebelumnya. Apabila kita bandingkan dengan variabel vocab sebelumnya, kita akan melihat bahwa
pada urutan tersebut berisikan karakter sesuai dengan contoh kata yang kita berikan tadi
sebelumnya (index pada vocab dimulai dari 0, sehingga kita mengawali dengan 39 dan bukan 40).

Dengan menggunakan fungsi tf.keras.layers.StringLookup() yang sama, kita juga bisa

mencari karakter dari kamus vocab kita berdasarkan index yang diberikan. Perhatikan sintaks
berikut ini.

113
 Ketika kita perhatikan hasilnya, maka kita akan melihat hasil pembentukan karakter
berdasarkan lokasi index dari tiap karakter tersebut. Namun ketika kita lihat hasilnya, hasilnya
berbentuk unicode yang terpisah. Kita akan mencoba untuk menggabungkan kembali karakter
tersebut agar lebih mudah untuk dilihat.

Fungsi yang kita gunakan untuk menggabungkan teks unicode adalah

tf.strings.reduce_join(). Dengan menambahkan fungsi .numpy() akhirnya, kita akan mengubah
tensor menjadi array numpy.

Pre-Processing Data - Vectorize Text

Kita telah memahami bagaimana cara kita akan mengubah data berbentuk teks menjadi
sebuah angka dari contoh sebelumnya. Kita akan mencoba untuk mengaplikasikan konsep tersebut
pada data teks Shakespeare yang kita miliki.

Kita akan menggunakan fungsi tf.strings.unicode_split() seperti yang kita lakukan

sebelumnya, untuk mengubah seluruh karakter pada variabel text menjadi berbentuk unicode, lalu
menggunakan variabel ids_from_chars kita akan mengubah teks unicode tersebut menjadi angka
index. Kita melihat bahwa ukuran dari variabel all_ids yang berisikan angka karakter dari teks
Shakespeare sudah sama dengan ukuran karakter dari teks Shakespeare tersebut.

114
 Kita akan mencoba untuk menampilkan 10 karakter pertama dari variabel all_ids tersebut.
Kita akan melakukan decode juga untuk mengembalikan karakter tersebut menjadi karakter yang
bisa dibaca manusia, dan juga mengubahnya menjadi Array NumPy.

Kita membentuk seluruh data tersebut menjadi sebuah dataset dengan menggunakan fungsi
tf.data.Dataset.from_tensor_slices(). Kita dapat menampilkan 10 karakter pertama dengan
menggunakan iterasi. Kita sekarang akan mencoba untuk menampilkan 100 data. Kita nantinya
akan mengelompokkan data kita menjadi beberapa batch dengan ukuran karakter masing - masing
adalah 100 karakter. Kita menggunakan seq_length +1 karena perhitungan batch dimulai dari
angka 1 (bukan 0 seperti index) sehingga ukuran batch kita tetap 100. Kita juga akan memberikan
parameter drop_remainder = True agar Tensorflow membuang sisa data apabila jumlah data tidak
habis dibagi dengan 100 dan jumlah batch yang kita tentukan. Kita akan mencoba untuk melihat isi
dari batch pertama dengan menggunakan iterasi. Perhatikan sintaks berikut ini.

115
 Kita akan mencoba untuk menggabungkan seluruh karakter tersebut menjadi sebuah kata
yang lebih mudah dibaca. Karena kita akan menggunakan fungsi ini berkali - kali nantinya, kita
akan mengemas fungsi ini menjadi sebuah function pada Python. Perhatikan function berikut ini.

Setelah kita membentuk function tersebut yang akan menggabungkan seluruh unicode yang
dihasilkan, kita akan mencoba untuk melihat kembali hasil dari seluruh karakter pada batch
pertama agar lebih enak dilihat. Perhatikan sintaks berikut ini.

116
 Data pada tiap batch ini yang nantinya akan kita gunakan untuk melatih model LSTM yang
akan kita buat. Kita telah memahami bagaimana bentuk data yang akan kita berikan nanti kepada
model. Hal berikutnya yang akan kita pahami adalah kita akan membuat sebuah fungsi yang dapat
menggeser input dari batch yang telah kita hasilkan.

Sebagai sebuah contoh, apabila kita memberikan sebuah kata “Tensorflow” dalam sebuah
list, maka fungsi yang kita buat tersebut akan memecah kata tersebut berdasarkan karakternya
dimana yang pertama akan mengembalikan sebuah input, lalu berikutnya akan mengembalikan
input yang telah digeser 1 karakter selanjutnya. Kita akan mencobakan fungsi tersebut pada data
batch pertama yang telah kita buat sebelumnya. Perhatikan sintaks berikut ini.

117
Membuat Batch dan Model

Pada proses sebelumnya, kita telah melihat bagaimana kita melakukan beberapa manipulasi
data input dan juga bagaimana cara mengelompokkan data teks input kita menjadi sebuah batch.
Pada bagian ini, kita akan mencoba membahas mengenai bagaimana kita akan membuat batch
tersebut pada seluruh train data yang kita miliki, lalu kita akan mencoba membahas mengenai
model LSTM yang akan kita buat.

Kita akan membuat 64 batch dari data teks Shakespeare yang kita miliki. Disini kita juga
akan menentukan nilai buffer adalah 10.000. Kita sudah membahas konsep batch dan buffer pada
materi Bab 4D - Reinforcement Learning ketika kita membahas mengenai Deep Q-Network.
Singkatnya, variabel dataset yang kita buat dapat menampung total 10.000 karakter didalamnya.
Kita akan memasukkan batch kita satu persatu ke dalam buffer ini (ingat jumlah data per 1 batch
adalah 100 karakter). Apabila jumlah karakter mencapai 10.000, maka data terlama yang ada dalam
buffer tersebut akan digeser. Kita akan mengaktifkan parameter drop_remainder = True yang akan
membuang sisa data yang tidak habis dibagi 100 dalam sebuah batch. Kita juga akan melakukan
pengacakan data dengan memberikan fungsi .shuffle() di dalamnya. Kita akan mencoba untuk
melihat hasil dari variabel dataset tersebut.

118
 Ketika kita melihat hasil output dari dataset, kita hanya akan melihat bahwa output
menunjukkan hanya elemen tensor dari dataset asli tersebut. Setelah ini, kita akan membuat
beberapa variabel yang digunakan untuk membuat model LSTM pada langkah selanjutnya.

Kita membuat variabel bernama vocab_size untuk mendapatkan panjang dari karakter unik
pada teks Shakespeare kita. Kita juga akan menuliskan jumlah hidden layer yang akan kita
gunakan nantinya dalam variabel embedding_dim sebesar 256 layers. Kita juga akan menuliskan
jumlah unit RNN yang akan digunakan untuk LSTM kita nanti sebanyak 1024 unit. Setelah ini kita
akan membangun sebuah model LSTM yang akan kita gunakan untuk membuat text generator.
Perhatikan sintaks berikut ini.

119
 Kita akan membuat sebuah class untuk model LSTM yang akan kita buat, dimana model ini
menerima 3 buah input, yaitu vocab_size, embedding_size, dan juga rnn_units yang merupakan
variabel yang telah kita buat sebelumnya. Kita akan membuat sebuah inisialisasi variabel lokal
yang akan digunakan dalam class tersebut dengan menggunakan def __init__().
Variabel lokal pertama yang akan kita buat adalah embedding, yang kita tuliskan sebagai
variabel lokal self.embedding dengan menggunakan tf.keras.layers.Embedding(). Konsep dari
word embedding ini adalah kita akan mengambil index dari teks tersebut (yang sudah kita ubah
menjadi angka sebelumnya) lalu kita akan mengubah angka index tersebut menjadi desimal dengan
mengaplikasikan bobot (weight) pada angka tersebut. Kita akan membutuhkan ukuran dari data
input tersebut, dimana ukurannya kita dapatkan yaitu 66 dari variabel vocab_size yang kita buat
sebelumnya. Kita juga akan mengeluarkan ukuran dari embedding tersebut sesuai dengan nilai pada
variabel embedding_dim yang kita tuliskan, dimana hasil keluarannya adalah 256 layers.
Variabel kedua yang akan kita buat adalah LSTM yang akan kita gunakan. Kita sudah bahas
pada bagian teori sebelumnya mengenai LSTM, dan yang akan kita gunakan adalah Gate
Recurrent Unit (GRU). Disini parameter yang akan kita berikan adalah jumlah dimensi unit hasil
keluarannya, dimana kita sudah menentukannya sebelumnya sesuai dengan nilai pada variabel
rnn_units, yaitu 1024 unit. Disini kita juga memberikan parameter return_sequences = True.
Apabila True, maka GRU akan mengembalikan output tersebut tiap kali kita melakukan iterasi
sedangkan apabila False, maka output tersebut tidak akan dikeluarkan dan hanya dilanjutkan ke
proses selanjutnya. Kita ingin melihat urutan dari karakter yang dihasilkan untuk membentuk suatu
teks, maka dari itu kita akan memasang nilainya sebagai True (default = False). Disini kita juga
akan memberikan parameter return_state = True. Apabila True, maka GRU akan mengembalikan
juga nilai state dari GRU tersebut bersamaan dengan output (default = False). State ini akan
menunjukkan kondisi dari GRU. Apabila nilainya None, maka sebagai pengganti akan diberikan
sebuah array numpy bernilai 0.

120
 Variabel ketiga yang kita buat adalah Dense Layers yang menggunakan fungsi
tf.keras.layers.Dense(). Pada variabel ini, kita akan menuliskan ukuran dari output yang kita
inginkan dari neural network yang kita buat.
Setelah kita membuat ketiga komponen yang akan digunakan dalam model neural network
kita, kita akan menyusun seluruh komponen ini dalam sebuah fungsi bernama call(). Kita akan
mengambil nilai input dalam variabel x. Setelah itu, kita akan memasukkan nilai variabel x tersebut
dalam variabel self.embedding yang kita buat, lalu kita akan memberikan parameter training untuk
melatih dan memberikan bobot pada tiap index karakter yang ada pada input. Kita akan mengecek
state dari model tersebut, dimana pada awalnya kita akan menyatakan nilai state adalah None.
Apabila nilainya None, maka kita akan mengambil state (kondisi) awal yang kita dapatkan dari
GRU, dimana apabila state bernilai None maka akan mengembalikan sebuah array numpy bernilai
0. Selanjutnya kita akan memasukkan x dalam variabel self.GRU. Kita ingat bahwa variabel
self.GRU ini akan mengembalikan output dan juga state dari GRU setelah diproses. Kita akan
melanjutkan nilai x tersebut pada variabel terakhir yaitu Dense Layers yang berfungsi untuk
menampung nilai output. Terakhir kita akan mengecek apakah kita memiliki nilai state atau tidak,
apabila iya maka kita akan mengembalikan output dan juga state, apabila tidak, maka kita hanya
akan mengembalikan nilai output saja.
Kita telah membahas sedikit bagaimana cara kerja dari model LSTM menggunakan GRU
yang kita buat sebelumnya. Kita akan mencoba untuk memanggil model tersebut dalam sebuah
variabel bernama model. Kita tidak lupa memberikan beberapa parameter input didalamnya, yaitu
variabel yang kita buat vocab_size, embedding_dim, dan juga rnn_units. Perhatikan sintaksnya
berikut ini.

121
 Untuk memahami alur dari kerja model tersebut, kita dapat melihat gambar berikut ini.

Tiap karakter sepanjang nilai seq_length akan diberikan pada self.embedding dengan
ukuran sebesar [batch_size, 1]. Ketika kita masukkan pada self.embedding, maka kita akan
mendapatkan data dengan ukuran sebesar [batch_size, embedding_dim]. Setelah itu proses akan
dilanjutkan ke dalam GRU dan kita akan mendapat data dengan ukuran [batch_size, rnn_units].
Ketika hasil GRU kita masukkan pada layer terakhir yang merupakan layer output, maka hasilnya
akan berubah menjadi ukuran [batch_size, vocab_size]. Ketika kita nanti akan melihat ukuran dari
output yang dihasilkan, maka kita akan melihat bahwa ukuran data per batch yang kita miliki akan
seukuran dengan [batch_size (baris), seq_length (kolom), vocab_size (dimensi)].

122
 Kita dapat mengecek isi dari parameter yang akan dihasilkan oleh model tersebut dengan
menggunakan fungsi .summary(). Perhatikan sintaksnya berikut ini.

Kita melihat bahwa kita memiliki total sebanyak 4 juta parameter yang akan dilatih oleh
model tersebut. Hal ini wajar karena kita memiliki jumlah data karakter yang banyak juga dalam
teks yang kita miliki, sehingga jumlah parameter yang dihasilkan juga akan banyak.
Setelah ini, kita akan mencoba untuk melihat seperti apa ukuran dari hasil output prediksi
dari model yang kita buat, sebelum kita akan menggunakan model kita pada proses pelatihan. Kita
dapat mencoba untuk memasukkan 1 batch terlebih dahulu ke dalam model, lalu kita dapat melihat
ukurannya dengan menggunakan fungsi .shape(). Perhatikan sintaks berikut ini.

123
 Kita melihat bahwa hasil prediksi dari model yang kita buat akan menghasilkan sebuah hasil
dengan ukuran (64, 100, 66) dimana nilai ini adalah batch_size, sequence_len, dan vocab_size.
Kita akan mencoba untuk melihat, seperti apa bentuk dari data yang dihasilkan ini. Apabila kita
mencoba untuk mengambil salah satu contoh dari batch yang kita prediksi tersebut, kita akan
mendapatkan output seperti berikut ini.

Perhatikan bahwa data tersebut merupakan data index dari karakter yang terbentuk. Index
tersebut merupakan hasil prediksi dari batch pertama, sehingga ketika kita memberikan input pada
model, maka model kita akan melakukan prediksi bahwa dari data batch pertama yang diberikan,
maka akan dilanjutkan dengan hasil keluaran dari variabel sampled_indices yang kita buat. Karena
variabel sampled_indices tersebut masih berupa index angka, kita akan mengubah index tersebut
menjadi bentuk karakter dengan menggunakan kamus dari variabel vocab yang kita buat
sebelumnya. Perhatikan sintaks berikut ini.

124
 Perhatikan bahwa hasil prediksi dari model yang ditampilkan pada variabel
sampled_indices sangatlah berantakan dan tidak bisa dimengerti oleh manusia. Hal ini wajar
karena kita belum melatih model kita, sehingga tanpa adanya pelatihan yang diberikan kepada
model, maka nilai akurasi dari model kita akan sangat jelek sekali, sehingga model kita akan
menampilkan hasil prediksi yang tidak dapat dimengerti. Kita akan masuk dalam proses untuk
melatih model kita setelah ini.

Melatih Model dan Melakukan Evaluasi

Sama seperti model Deep Learning pada umumnya, kita akan memberikan sebuah loss
function pada model kita. Yang akan kita gunakan adalah Sparse Categorical Crossentropy
dengan memanggil fungsinya ada;aah tf.losses.SparseCategoricalCrossentropy(). Kita
menggunakan tipe loss ini apabila kita memiliki data dimana label yang kita miliki berupa angka
(kategori berbentuk angka) dan nilai y_pred yang dihasilkan berbentuk sebuah list (nilai y_test
dapat berbentuk sebuah integer ataupun nilai tertentu). Kita juga akan memberikan parameter
from_logits = True, yang memiliki arti bahwa prediksi yang kita lakukan merupakan prediksi
sebuah nilai tensor yang merupakan sebuah karakter, sehingga y_pred akan mengembalikan
sebuah probability distribution. Perhatikan penulisan sintaksnya berikut ini.

Kita akan mencoba melihat sekilas nilai loss yang dihasilkan dari percobaan yang kita
lakukan dengan hanya menggunakan 1 batch sebelumnya, yaitu dengan membandingkan variabel
target_example_batch yang merupakan nilai y_test dan juga variabel
example_batch_predictions yang merupakan hasil prediksi y_pred dari model yang kita buat.
Kita akan mencoba untuk memasukkan kedua nilai tersebut dalam loss function yang kita buat, lalu
kita akan melihat ukuran dan juga hasil dari nilai loss dari prediksi yang dilakukan. Perhatikan
sintaks berikut ini.

125
 Dari hasil komputasi yang dilakukan, kita dapat melihat bahwa nilai loss yang dihasilkan
adalah 4,19. Kita tidak tahu apakah nilai tersebut merupakan nilai yang baik atau tidak, karena kita
tidak memiliki pembanding untuk menentukan apakah nilai loss tersebut baik atau tidak. Yang telah
kita ketahui adalah bahwa setelah kita melihat contoh dari salah satu prediksi pada variabel
example_batch_predictions sebelumnya, kita tidak dapat memahami arti kalimat dari hasil
prediksi model tersebut karena kita tidak melakukan pelatihan terhadap model sebelumnya. Untuk
mendapat gambaran yang lebih jelas, kita akan mencoba untuk mengubah nilai loss tersebut
menjadi nilai exponential, untuk mendapatkan gambaran nilai loss yang lebih jelas. Apabila nilai
loss yang dihasilkan dari nilai exponential tersebut mendekati nilai dari jumlah vocab_size yang
kita miliki, maka dapat diartikan bahwa nilai tersebut kurang baik. Perhatikan sintaksnya berikut
ini.

Perhatikan dari hasil sintaks diatas bahwa kita mendapatkan nilai exponential loss sebesar
66,04594, dimana nilai ini mendekati nilai vocab_size kita yaitu 66. Hal ini wajar karena kita
belum melakukan pelatihan apapun pada model kita, sehingga akurasinya sangat jelek sekali.
Setelah ini, kita akan mencoba untuk memberikan gradient descent pada model kita, berupa Adam
Optimizer, agar performa model dapat menjadi lebih baik lagi. Perhatikan sintaks berikut ini.

126
 Kita juga akan membuat sebuah callbacks yang akan digunakan untuk menyimpan bobot
(weight) dari model kita tiap epoch yang nanti akan berjalan. Kita akan menyimpannya dalam
sebuah folder bernama training_checkpoint. Perhatikan sintaksnya berikut ini.

Setelah seluruh komponen yang kita butuhkan telah terbentuk, kita akan mencoba untuk
menuliskan jumlah epoch yang akan kita gunakan untuk melatih model kita. Kita akan mencoba 20
epoch/episode terlebih dahulu. Setelah ini, kita akan memasukkan data kita, epochs, dan juga
callbacks dalam model kita dan kita akan memulai pelatihan model. Perhatikan sintaks berikut ini.

Ketika kita menjalankan sintaks diatas, kita akan mendapatkan hasil output seperti berikut
ini.

Kita dapat menunggu sampai proses pelatihan model tersebut selesai dilakukan.

127
 Terkadang, apabila kita menggunakan Google Colab untuk melakukan pelatihan model
GRU tersebut, kita akan memerlukan waktu yang cukup lama, tergantung dari GPU yang kita
lakukan untuk melakukan pemrosesan sintaks Python pada Google Colab. Kita dapat mengubah
GPU yang digunakan pada bagian runtime Google Colab, untuk mempercepat proses pelatihan
tersebut. Kita dapat lihat bagian runtime tersebut pada pojok kanan atas dekat foto profil akun
Google Colab yang kita miliki, lalu kita dapat klik tanda panah yang ada.

Kita dapat klik tombol Change runtime type, lalu kita akan memilih tipe GPU yang lebih
cepat untuk digunakan untuk melakukan proses.

Setelah kita klik tombol tersebut, kita akan ditampilkan halaman dari beberapa jenis GPU
yang dapat kita pilih untuk melakukan pemrosesan. Kita dapat mengubahnya menjadi T4 GPU, lalu
kita akan klik tombol Save untuk menyimpan perubahan tersebut. Namun apabila kita mengubah
tipe runtime, kita perlu menjalankan kembali seluruh sintaks yang kita buat dari awal. Apabila
proses pelatihan model cepat, kalian bisa abaikan langkah ini.

128
 Kita mengubah runtime untuk mengubah tipe pemrosesan yang dilakukan oleh Google
Colab. Hal ini dilakukan karena proses yang terjadi ketika kita melakukan pelatihan umumnya
akan memakan waktu sangat lama. Dengan mengubah GPU, kita bisa mempercepat proses tersebut,
namun kita perlu menjalankan ulang seluruh sintaks yang kita gunakan. Apabila kalian tidak
memiliki kendala apapun ketika melakukan pelatihan dengan tipe runtime sebelumnya, maka
kalian bisa mengabaikan tahap ini dan menunggu hingga proses pelatihan model selesai. Pada studi
kasus ini, kita akan menganggap bahwa kita mengganti runtime dan perlu menjalankan kembali
seluruh sintaks dari awal. Kita akan menunggu sampai proses selesai, lalu kita akan melihat
kembali output berikut ini.

Setelah ini, kita akan mencoba membuat sebuah class untuk melakukan prediksi satu step
berikutnya untuk membuat sebuah teks baru.

129
 Class yang dibuat diatas merupakan class yang digunakan untuk melakukan prediksi teks
satu step berikutnya. Fungsi tersebut terlihat kompleks, namun kita akan mencoba untuk
menjelaskan konsep dari fungsi tersebut terlebih dahulu. Untuk lebih mudah memahami konsepnya,
kita akan mencoba untuk melihat ilustrasi berikut ini terlebih dahulu.

130
 Ketika kita memberikan sebuah karakter sebagai input pada model, maka model akan
mencoba untuk melakukan prediksi karakter selanjutnya yang akan ditampilkan. Pada ilustrasi
diatas, ketika kita memberikan karakter “T”, maka setelah proses pengolahan pada model, kita
akan mendapatkan karakter “e” berikutnya. Karakter “e” ini akan dijadikan input untuk proses
selanjutnya, lalu kita akan mendapatkan karakter berikutnya yaitu “n” sampai proses prediksi ini
selesai pada akhirnya.
Apabila kita kembali untuk melihat proses sintaks yang kita buat pada class sebelumnya,
kita dapat melihat bahwa pada bagian inisialisasi pada def __init__(), kita akan menuliskan
beberapa variabel yang akan dibutuhkan seperti variabel self.temperature, self.model,
self.chars_from_ids, dan self.ids_from_chars. Kita juga akan membuat sebuah variabel skip_ids
yang berisi karakter ‘[UNK]’. Karakter ‘[UNK]’ ini akan otomatis dibuat apabila variabel
ids_from_chars tidak ditemukan dalam keseluruhan index yang kita miliki. Variabel sparse_mask
akan mengubah seluruh nilai index apabila ditemukan karakter ‘[UNK]’ menjadi -inf sebagai
format float apabila ditemukan index yang nilainya tidak ditemukan dari kamus pada variabel
vocab kita. Terakhir kita akan menerapkan variabel mask tersebut pada model kita.
Berikutnya kita akan membuat fungsi yang akan membuat prediksi satu step kedepan.
Prediksi ini kurang lebih mirip dengan beberapa step yang telah kita bahas sebelumnya. Kita akan
memecah teks input yang diberikan menjadi bentuk unicode, lalu kita akan memasukkan
seluruhnya kedalam fungsi ids_from_chars dan mengubah seluruhnya menjadi tensor, untuk
menghasilkan data angka dari data teks yang kita masukkan.

131
 Selanjutnya kita akan menuliskan model yang telah kita buat sebelumnya. Kita juga akan
memasukkan input yaitu input_ids dan juga states adalah None sesuai yang didefinisikan dalam
fungsi, dan juga menuliskan return_state = True agar model kita dapat mengembalikan state dari
model tersebut.
Untuk mengambil hasil prediksi karakter yang dibentuk, kita akan menggunakan indexing,
dimana kita akan mengambil karakter terakhir saja yang dibentuk oleh hasil prediksi model kita.
Pada variabel predicted_logits, ukuran data yang terbentuk akan mengikuti format [batch_size,
sequence_len, vocab_size] sesuai yang kita telah lihat sebelumnya. Kita akan menambahkan
self.prediction_mask yang kita buat pada variabel predicted_logits, lalu dari predicted_logits
tersebut, kita akan mencoba untuk mengambil beberapa sample dari logits, lalu kita akan
mendapatkan index dari teks tersebut. Terakhir kita akan mengubah angka index tersebut kembali
menjadi sebuah teks. Pada akhirnya, fungsi tersebut akan mengembalikan karakter yang diprediksi
dan juga state yang dihasilkan dari model tersebut. Fungsi tersebut terlihat kompleks, namun
sesungguhnya fungsi tersebut merupakan rangkuman dari beberapa metode yang telah kita bahas
sebelumnya ketika kita melakukan prediksi pada sebuah batch.
Setelah kita membentuk class tersebut yang memuat fungsi untuk melakukan prediksi, kita
akan memasukkan fungsi tersebut dalam sebuah variabel one_step_model. Perhatikan sintaks
berikut ini.

Berikutnya, kita akan membuat proses yang akan kita gunakan untuk prediksi. Untuk
mengetahui berapa lama proses prediksi ini dapat berjalan, kita akan mencoba untuk menggunakan
fungsi time dari library time. Ini akan membuat kita dapat mencatat waktu eksekusi dari proses
pelatihan model kita. Perhatikan sintaks berikut ini.

132
 Kita akan menuliskan states adalah None, lalu kita akan menyatakan sebuah konstanta
yaitu ‘ROMEO : ‘, dimana kita akan memulai prediksi dengan diawali dari karakter ‘ROMEO : ’.
Kita akan mencoba untuk melakukan iterasi sebanyak 1000 kali, dimana pada proses ini kita akan
menghasilkan 1000 karakter berikutnya, dengan memanggil fungsi
one_step_model.generate_one_step() yang kita buat sebelumnya. Nilai prediksi ini akan kita
tambahkan pada list yang akan menampung seluruh data hasil prediksi. Kita akan mengambil
menggabungkan seluruh hasil dalam list menjadi sebuah data besar, lalu kita akan menggunakan
numpy untuk kembali membuatnya menjadi sebuah array, lalu kita akan melakukan decode agar
bentuknya berubah dari unicode menjadi format yang dapat dibaca oleh manusia. Kita juga akan
mencoba untuk melihat lamanya proses prediksi ini terjadi. Setelah kita menjalankan sintaks diatas,
kita akan mencoba untuk melihat hasilnya berikut ini.

133
 Ketika kita melihat hasil dari prediksi yang dilakukan oleh model kita, hasilnya tidak buruk,
hanya dengan waktu 3,15 detik, model kita berhasil untuk mengeluarkan prediksi 1000 karakter
setelah kata ‘ROMEO : ‘ yang kita tuliskan. Apabila kita lihat hasil prediksi sekilas, kita dapat
mengerti arti dari beberapa kata dan juga kalimat yang dihasilkan oleh proses prediksi. Namun
mungkin kita belum dapat memahami konsep dari teks yang dihasilkan oleh proses prediksi. Kita
dapat mencoba untuk melatih model kita kembali mungkin dengan jumlah proses epoch yang lebih
banyak, ataupun dengan parameter lain yang dapat meningkatkan akurasi dan performa lebih baik
lagi.

134
Membuat Ulang Model dengan Performa yang Lebih Baik

Kita telah melihat performa dari model prediksi yang kita lakukan sebelumnya. Dapat
dilihat bahwa setelah proses pelatihan, kita mulai dapat memahami beberapa kata yang diprediksi
oleh model kita. Namun mungkin kata - kata tersebut tidak memiliki sebuah konteks dan ada
beberapa kata yang mungkin kita tidak mengerti. Pada bagian kali ini, kita akan mencoba cara lain
yang dapat digunakan untuk meningkatkan performa dari model kita. Pertama kita akan mencoba
untuk menambahkan optimizer pada tiap step iterasi yang dilakukan. Perhatikan sintaks berikut ini.

Kita akan mengambil data input, lalu untuk tiap step prediksi yang kita lakukan, kita akan
memberikan sebuah optimizer dan juga gradient descent. Dengan hal ini, kita berharap bahwa
model kita akan memiliki performa yang lebih baik dan juga nilai loss yang lebih kecil.
Kita akan memasukkan class yang kita buat ini ke dalam variabel model yang kita buat.
Kita akan memasukkan beberapa parameter didalamnya, dimana kita akan memasukkan input
berupa vocab_size, embedding_dim, dan juga rnn_units yang sebelumnya telah kita definisikan.
Perhatikan sintaks berikut ini.

135
 Model tersebut merupakan model baru yang kita buat, dimana kita menambahkan optimizer
pada model tersebut agar memiliki performa yang lebih baik. Setelah itu, kita akan melakukan
compile pada model kita dengan memasukkan Adam Optimizer yang akan kita gunakan dan juga
loss function yang kita buat dengan menggunakan fungsi
tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True). Perhatikan penulisan
sintaksnya berikut ini.

Dengan memberikan optimizer tambahan pada model, kita berharap bahwa performa dari
model kita akan menjadi lebih baik lagi dalam melakukan prediksi karakter. Kita akan mencoba
untuk membuat proses pelatihan untuk model yang baru kita buat ini. Perhatikan sintaks berikut ini.

136
 Kita akan melatih model kita dengan menggunakan epoch sejumlah 100 episode. Kita akan
memanggil fungsi dari Tensorflow yaitu tf.metrics.Mean() yang kita gunakan untuk mereset nilai
state. Kita akan membuat proses iterasi pelatihan kita sebanyak 100 episode. Pada tiap iterasi, kita
akan mencoba untuk menghitung waktu prosesnya, dan juga akan mereset nilai state tiap iterasi.
Kita akan melakukan prediksi dengan menggunakan model kita, lalu kita akan mengupdate nilai
state dengan nilai loss pada tiap iterasi. Untuk tiap 50 batch yang telah kita lalui, kita akan
menampilkan hasil lossnya. Selain itu, untuk tiap 5 episode yang telah dilalui, kita akan membuat
sebuah checkpoint dengan menyimpan bobot dari model tersebut pada tiap episodenya. Terakhir,
kita akan menampilkan nilai dari loss dan juga waktu yang dibutuhkan untuk eksekusi tiap episode.
Terakhir, kita akan menyimpan bobot akhir dari model yang telah kita latih dengan nama sesuai
pada variabel checkpoint_prefix ditambah angka “_100”. Apabila kita menjalankan sintaks
tersebut, kita akan mendapatkan hasil seperti berikut ini.

137
 Hasil output tersebut akan terus berlanjut sampai pada episode ke 100. Apabila kita lihat
rata - rata waktu proses dari tiap episode, maka kita akan selesai melatih model kita dalam waktu
sekitar 1200 detik (20 menit). Proses ini dilakukan dengan menggunakan GPU dari Google Colab
agar prosesnya dapat menjadi lebih cepat.
Setelah 100 episode dilewati dan model dilatih, kita dapat lihat nilai loss yang dihasilkan
pada episode ke - 100.

Kita dapat lihat bahwa rata - rata nilai loss yang dihasilkan pada tiap batch dan juga episode
dapat terbilang cukup stabil, yaitu di sekitar 0,7. Kita mungkin tidak perlu melatih model kita
dengan jumlah episode sebanyak 100, dan kita bisa mencoba untuk melihat kira - kira model kita
akan memiliki nilai loss terendah pada episode tertentu.

138
 Setelah kita selesai melatih model kita untuk 100 episode, kita bisa juga melakukan
pelatihan ulang pada model kita dengan jumlah episode yang mungkin optimal, sehingga tidak
perlu sampai 100 episode (apabila diperlukan). Setelah ini, kita akan coba untuk melakukan
prediksi terhadap karakter berikut yang dikeluarkan oleh model. Sama seperti proses pada model
sebelumnya, kita dapat membuat model class OneStep untuk melakukan prediksi berikutnya
terhadap data kita. Perhatikan sintaks berikut ini.

139
 Sintaks tersebut sama seperti sintaks yang kita buat sebelumnya untuk melakukan prediksi
karakter 1 step berikutnya. Untuk mengetahui cara kerja dari fungsi tersebut, kalian dapat melihat
kembali penjelasan sebelumnya ketika kita menggunakan model pertama. Kita akan memanggil
class prediksi ini dalam sebuah variabel one_step_model.

Kita akan mencoba membuat iterasi yang digunakan untuk menghasilkan prediksi kita.
Bentuk penulisan sintaks yang digunakan kurang lebih mirip dengan yang kita gunakan pada model
sebelumnya. Perhatikan sintaks berikut ini.

Kita akan memanggil library time untuk menghitung waktu yang dibutuhkan untuk
melakukan prediksi nantinya. Kita akan memasukkan fungsi time tersebut dalam sebuah variabel
start untuk menghitung waktu awal. Kita juga akan menuliskan nilai state awal adalah None. Sama
seperti prediksi yang kita lakukan pada model sebelumnya, kita akan memberikan beberapa
karakter pertama untuk memulai, yaitu ‘ROMEO:’. Kita akan mencoba untuk melakukan prediksi
sebanyak 1000 karakter. Dengan menggunakan iterasi, kita akan mencoba memanggil model
prediksi kita dengan memberikan input karakter dan juga statesnya. Kita akan menambahkan
hasilnya pada list yang kita buat.

140
 Ketika kita menjalankan sintaks tersebut, kita akan melihat hasilnya berikut ini.

Kita lihat bahwa prediksi tersebut berlangsung dengan cukup cepat, sekitar 4 detik. Kita
juga melihat hasil prediksi yang dilakukan, bahwa model sudah bisa menghasilkan teks yang lebih
mudah untuk kita pahami. Performanya juga lebih baik dan kita mulai dapat mengerti arti dari
beberapa kalimat percakapan yang muncul walaupun belum sebaik percakapan manusia pada
umumnya.

141
 Apabila kita cukup puas dengan hasil dari model prediksi yang dibuat, kita bisa menyimpan
model tersebut dalam sebuah file agar dapat digunakan kembali nantinya. Kita akan menggunakan
fungsi saved_model.save() dari Tensorflow untuk menyimpan model tersebut dalam sebuah file.
Kita juga akan menggunakan fungsi saved_model.load() dari Tensorflow untuk memanggil
kembali model tersebut dari file agar dapat digunakan kembali ketika kita ingin melakukan
prediksi.

Ketika kita menyimpan model tersebut, maka sebuah folder baru pada Google Colab akan
terbentuk, yang berisikan seluruh komponen pembentuk model tersebut.

Kita dapat menggunakan kembali model yang telah kita panggil tersebut untuk melakukan
prediksi. Kita akan mencoba untuk melakukan sebuah prediksi 100 karakter berikutnya. Perhatikan
penulisan sintaks berikut ini.

142
 Advanced NLP : Transformers
Materi terakhir pada Bab NLP ini akan membahas mengenai Transformers. Arsitektur
mengenai Transformers ini mulai diperkenalkan sejak Juni 2017, dan masih terus dikembangkan
sampai sekarang. Tujuan utama dari Transformers ini adalah untuk mengerjakan seluruh kasus
yang berhubungan dengan translasi kata. Translasi disini dapat berarti menerjemahkan bahasa
manusia sehingga mudah dimengerti oleh komputer dan komputer dapat memberikan kembali
jawaban yang dapat dimengerti oleh manusia. Berdasarkan sejarah yang dikutip dari website resmi
Transformers (huggingface.co), berikut sejarah singkat mengenai Transformers.

Juni 2018
- GPT, model Transformers pertama yang telah
dilatih dirilis, digunakan untuk melakukan tuning
pada beberapa kasus terkait NLP

Oktober 2018
- BERT, model Transformers yang lebih besar yang telah
dilatih dirilis, dapat menyimpulkan konteks dalam sebuah
kalimat
Februari 2019
- GPT-2, pengembangan GPT, namun tidak langsung
dirilis karena ada masalah terkait etis

Oktober 2019
- DistilBERT, pengembangan dari BERT dimana
memiliki performa 60% lebih cepat dan memori lebih
sedikit 40% dibanding BERT, dan masih memiliki 97%
performa dari model BERT yang asli.
- Munculnya model BART dan T5, dua model besar
lainnya yang menggunakan arsitektur asli Transformers

May 2020
- GPT-3, pengembangan GPT-2 dimana model ini dapat
bekerja tanpa perlu adanya tuning yang baik

143
 Seluruh model Transformers yang telah disebutkan (GPT, BERT, BART, T5, dan lainnya)
telah dilatih terlebih dahulu dengan jumlah data yang besar dengan menggunakan teknik Self-
Supervised Learning, dimana berbeda dengan algoritma Supervised Learning yang kita kenal,
model Transformers ini secara otomatis akan dilatih berdasarkan input yang diberikan pada model,
sehingga tidak perlu adanya keterlibatan manusia untuk memberikan label pada data. Karena model
ini sudah dilatih terlebih dahulu, teknik ini kita namakan transfer learning.

Transfer Learning
Transfer Learning merupakan istilah yang digunakan ketika kita menggunakan model
yang telah dilatih sebelumnya, baik oleh kita sendiri maupun menggunakan model yang telah
dilatih oleh orang lain. Umumnya, kita membuat model kita sendiri ketika kita akan mencoba
melakukan analisis terhadap data kita dari awal, dengan memberikan beberapa pembobotan acak
dan model tidak mengetahui apapun terkait data yang akan dianalisa. Proses transfer learning ini
umumnya akan membutuhkan data yang besar dan waktu yang lama untuk pemrosesan, dan
membutuhkan biaya komputasi yang besar.

Fine Tuning
Fine Tuning merupakan istilah lain yang mungkin akan kita sering dengar apabila
menggunakan Transformers. Proses ini biasa dilakukan apabila model telah melewati tahap
pretrained sebelumnya. Dengan menggunakan model yang telah dilatih sebelumnya pada proses
Transfer Learning, kita akan melatih data spesifik yang kita miliki dengan model tersebut. Kalau
kita perhatikan disini, mengapa kita tidak langsung melatih model langsung dengan menggunakan
test data?

144
 Ada beberapa alasan seperti karena kita memiliki model yang telah dilatih dengan data yang
begitu besar, ini akan memudahkan kita untuk mendapatkan hasil yang lebih akurat dan spesifik
terkait data spesifik yang kita gunakan, sehingga kita tidak akan mendapatkan konteks yang besar.
Selain itu, karena model tersebut telah dilatih sebelumnya, proses fine tuning ini juga tidak akan
membutuhkan waktu lama untuk mendapat hasil yang akurat.

Arsitektur Transformers
Secara umum, sebuah model Transformers hanya terdiri dari encoder, decoder, ataupun
gabungan keduanya encoder-decoder (sequence-to-sequence model). Kita akan membahas sedikit
mengenai gambaran model dari Transformers berikut ini.
Model Encoder bertujuan untuk mendapatkan pemahaman mengenai teks input yang
diberikan. Beberapa contoh kasus yang menggunakan model ini adalah klasifikasi kalimat seperti
Sentiment Analysis, dan juga Named Entity Recognition. Model yang menggunakan Encoder ini
contohnya adalah BERT dan DistilBERT.
Model Decoder bertujuan untuk mendapatkan prediksi terkait kata ataupun kalimat dari
input yang diberikan, untuk mendapatkan kelanjutan dari kalimat tersebut. Beberapa contoh kasus
yang menggunakan model ini adalah Text Generation, ChatGPT. Model yang menggunakan
Decoder ini contohnya adalah GPT, GPT-2, GPT-3, Transformer XL, dan lainnya.
Model Encoder-Decoder atau Sequence-to-Sequence bertujuan untuk mendapatkan hasil
Text Generation yang membutuhkan sebuah input, seperti melakukan translasi ataupun menarik
kesimpulan dari sebuah kalimat. Beberapa contoh model ini adalah BART dan T5.

145
 Berikutnya yang perlu kita perhatikan adalah Attention Layers. Jenis layers ini ada pada
beberapa bagian dalam encoder dan juga decoder, dimana fungsi utama dari layer ini adalah agar
model memperhatikan beberapa kata secara khusus ketika sedang membaca tiap kata pada sebuah
kalimat. Untuk mendapatkan konteksnya, kita coba lihat ilustrasi berikut. Ketika kita ingin
menggunakan Transformers untuk menerjemahkan kata bahasa Inggris : “You like this pasta” ke
bahasa Indonesia, maka Attention Layers perlu memperhatikan kata “You” dan mendapatkan arti
dari kata berikutnya “like” karena dalam bahasa Indonesia, kata “like” dapat memiliki makna
“mencintai” ataupun “menyukai”, sehingga tergantung dari konteks subjek yang digunakan,
Transformers dapat memberikan arti yang sesuai. Sama seperti ketika model akan menerjemahkan
kata “this”, maka model perlu memperhatikan kata “pasta” agar mendapatkan konteks kata “ini”
sesuai yang diinginkan, bahwa kita akan menunjuk objek “pasta” dan bukan “menunjukkan
arah”. Konsep dari Attention Layer ini diambil dari istilah bahwa sebuah kata memiliki arti
masing - masing, namun rangkaian kata akan memiliki maknanya tersendiri tergantung konteks.
Secara umum, letak dari encoder, decoder, dan attention layer pada arsitektur
Transformers dapat digambarkan pada diagram berikut ini.

146
 Berdasarkan fungsi dari masing - masing encoder, decoder, dan sequence-to-sequence,
kita akan mencoba untuk membahas sedikit aplikasi dari tiap jenis model.

Model Encoder (BERT)

Kita telah mengetahui sedikit mengenai model encoder bahwa model ini akan mendapatkan
konteks dari kata ataupun kalimat yang kita berikan. Cara kerja dari model ini adalah encoder akan
menggunakan seluruh kata yang kita berikan sebagai input langsung untuk dicek menggunakan
attention layer.
Model encoder ini terdiri dari beberapa neural network yang digunakan didalamnya,
dimana didahului dengan sebuah attention layer yang akan memberikan pembobotan untuk tiap
kata dalam kalimat dengan menghitung nilai dot product dari tiap embedding pada kata. Proses ini
disebut juga dengan multi-head attention. Hasil pembobotan tersebut akan diberikan kepada sebuah
feed-forward neural network untuk mengekstrak fitur tingkat tinggi berdasarkan hasil pembobotan
tiap kata yang diberikan. Umumnya, bentuk dari layer ini adalah dengan menggunakan dua layer
yang diantaranya ada ReLU activation function. Dengan ini, feed-forward neural network dapat
mengekstrak gambaran besar dari kalimat tersebut, lalu akan menghasilkan fitur - fitur yang
memiliki tingkat kepentingan tinggi dari kata - kata dalam kalimat tersebut. Fitur ini yang nantinya
akan diberikan kepada decoder pada proses selanjutnya untuk dapat menentukan prediksi dari kata
- kata tersebut.
Karena encoder ini bertujuan untuk mengekstrak fitur penting dari sebuah kalimat, maka
umumnya aplikasi dari encoder ini bertujuan untuk mendapatkan konteks umum dari kalimat yang
kita berikan. Beberapa contoh aplikasi NLP yang telah kita ketahui yang dapat diterapkan dengan
menggunakan prinsip encoder ini adalah Sentiment Analysis (dimana kita menentukan hasil emosi
dari tiap kalimat) ataupun Topic Modeling (menentukan konteks topik pada kalimat), dimana
kedua aplikasi ini menerapkan sistem klasifikasi di dalamnya untuk mendapatkan gambaran umum
dari kumpulan teks tersebut.

147
 Bidirectional Encoder Representation of Transformers (BERT) merupakan salah satu
contoh jenis Transformers yang berfungsi untuk menentukan konteks dari beberapa data yang
tidak memiliki label sebelumnya sehingga dapat memiliki sebuah label. BERT ini juga dilatih
dengan menggunakan konsep masked language modeling (MLM) dan juga next sentence prediction
(NSP), sehingga dapat dengan mudah melakukan prediksi terhadap sebuah kata yang
disembunyikan (kata kosong), namun tidak terlalu baik untuk menghasilkan sebuah kata baru.

Studi Kasus : BERT untuk Topic Modeling

Sebelumnya, kita telah membahas mengenai Topic Modeling dengan menggunakan metode
LDA dan NMF sebelumnya. Pada studi kasus ini, kita akan mencoba untuk membuat ulang model
untuk melakukan Topic Modeling dengan menggunakan metode BERT.

Menyiapkan Files

Kita akan membuat Topic Modeling dengan menggunakan data BBC News yang
sebelumnya kita gunakan untuk melakukan Topic Modeling. Kita akan menggunakan sintaks yang
sama seperti yang kita gunakan sebelumnya untuk membaca file CSV tersebut dari Google Drive.

148
 Kita akan mengecek terlebih dahulu apakah ada data yang kosong pada dataset ini. Kita
akan menghitung jumlah nilai Null pada dataframe. Perhatikan sintaks berikut ini.

Setelah memastikan tidak ada data yang kosong dan seluruhnya terisi, maka kita akan
mencoba untuk membuat model Transformers kita dengan menggunakan BERT.

Membuat Model BERT dengan BERTopic

Kita akan mencoba untuk membuat Topic Modeling dengan menggunakan BERT. Untuk
itu, kita memiliki sebuah module tersendiri, yaitu BERTopic, dimana BERTopic ini sebenarnya
adalah module Transformers BERT namun yang telah dimodifikasi sehingga dapat membuat
cluster untuk Topic Modeling. Kita akan install librarynya terlebih dahulu.

Pada model BERTopic ini, model ini telah dirancang untuk menghasilkan topik hasil
cluster dan juga probabilitas sebuah kata untuk masuk dalam topik tersebut, sama seperti konsep
Topic Modeling yang kita bahas sebelumnya. Sebelum kita memanggil fungsi BERTopic, kita
akan mencoba untuk menggunakan Count Vectorization dulu untuk menghapus seluruh stop
words yang ada pada teks yang akan kita masukkan nantinya.

149
 Kita akan memanggil fungsi BERTopic yang akan kita masukan pada variabel model.
Disini kita akan memberikan beberapa parameter seperti vectorizer_model. Vectorizer_model
dapat menerima basis model yang akan kita gunakan, dimana biasa kita menggunakan
CountVectorizer karena CountVectorizer dan BERTopic cukup sering digunakan bersamaan
dalam melakukan fine tuning. Kita juga akan memilih language = ‘english’ sebagai bahasa yang
digunakan, lalu kita juga akan memberikan parameter calculate_probabilities = True agar bisa
melihat nilai probabilitas tiap kata nantinya. Terakhir kita memberikan verbose = True agar kita
melihat informasi langkah yang dilakukan BERTopic ketika kita menjalankan model itu nantinya
pada pelatihan.
Setelah kita membentuk variabel model yang berisi BERTopic, maka kita akan
memasukkan data df[“description”] kedalam model, dengan terlebih dahulu mengubah bentuk
kolom dataframe tersebut menjadi sebuah list. Kita akan memasukkan data tersebut dalam model
dengan menggunakan fit_transform. BERTopic ini akan menghasilkan 2 output, dimana yang
pertama adalah kita bisa melihat pembagian topik yang dilakukan oleh BERTopic, lalu yang
berikutnya adalah kita bisa melihat probabilitas dari tiap kata itu untuk masuk ke dalam topik
tertentu. Kita akan menjalankan sintaks diatas, dan akan membutuhkan beberapa waktu untuk
melatih model tersebut, sampai akhirnya selesai.

150
 Setelah kita selesai melatih model, maka kita akan mencoba untuk membuat sebuah
dataframe baru, yang dinamakan df_topic. Dataframe ini akan mengambil data dari hasil
pelatihan model, dimana kita bisa menuliskan model.get_topic_info(). Kita bisa juga melihat head
dari dataframe tersebut, untuk melihat 10 model pertama. Data tersebut diurutkan berdasarkan
kemunculannya. Perhatikan sintaks berikut ini.

Dari dataframe tersebut, kita melihat nomor topik pada kolom Topic dari -1 sampai
seterusnya. Untuk topik dengan nomor -1 berarti berisi kata - kata yang banyak muncul pada
dokumen. Karena kita membahas data mengenai BBC, hal ini akan wajar apabila kita menemukan
banyak kata “BBC” pada data kita. Umumnya, kita dapat mengabaikan topik nomor -1 ini karena
apabila kata - kata yang umum muncul berkali - kali dalam dataset kita, akan mengurangi makna
yang dapat kita dapatkan dari kalimat tersebut (lihat konsep dari Count Vectorization).
Selain kolom Topic, kita juga melihat beberapa kolom lain seperti Name, merupakan nama
topik yang dibuat oleh model dengan menggabungkan kata - kata yang memiliki probabilitas tinggi
pada topik tersebut. Ada juga kolom Representation yang menampung isi kata pada topik tersebut,
dan juga ada kolom Representative_Docs yang memberikan contoh data yang masuk pada topik
tersebut menurut model.

151
 Terakhir, kita dapat memasangkan nomor topik yang kita dapat dari hasil output model
tersebut pada dataframe asli yang kita miliki. Nomor topik ini akan kita gabungkan dengan
dataframe df_topic,agar kita bisa melihat nama topik dari tiap baris data asli yang kita gunakan.
Perhatikan sintaksnya berikut ini.

Kita menggunakan merge untuk menggabungkan kedua dataframe data asli (df) dengan
dataframe topik (df_topic). Setelah itu, kita akan menggunakan str.split untuk memecah topik
tersebut agar lebih enak untuk dibaca. Ingat bahwa pada dataframe df_topic sebelumnya, contoh
penulisan nama topik yang dibuat oleh model adalah 0_strike_rail_strikes_union, sehingga kita
akan membuang angka “0” didepannya agar terlihat lebih rapi. Perhatikan hasil outputnya berikut
ini.

152
Model Decoder (GPT)

Sebelumnya kita telah membahas model encoder dan salah satu aplikasinya dalam Topic
Modeling, untuk menentukan topik dari sebuah teks, dengan menggunakan algoritma BERT. Pada
bagian kali ini, kita akan membahas mengenai model decoder yang ada pada Transformers.
Dalam sebuah model Transformers, mungkin model decoder bisa dikatakan yang berperan
penting dalam model tersebut. Hal ini disebabkan karena decoder yang berperan untuk melakukan
translasi bahasa yang digunakan dan membuat kesimpulan dari kalimat yang diterima. Umumnya,
decoder ini bekerja sama dengan menerima fitur yang dihasilkan oleh encoder. Karena encoder ini
akan menghasilkan fitur yang berupa teks, fitur - fitur ini akan diurutkan dan dimasukkan ke dalam
decoder.
Decoder akan menerima input yang diberikan secara langsung, ataupun input yang
diberikan dari hasil proses encoder. Salah satu jenis input umum yang dapat diberikan secara
langsung adalah sebuah kalimat yang diberikan masking (penanda). Contoh kalimat tersebut adalah
seperti ini : “I [MASK] to play basketball!”. Berdasarkan algoritma decoder, kita menginginkan
model tersebut untuk dapat melakukan prediksi mengenai kata apa yang tepat untuk menggantikan
“[MASK]” tersebut. Konsep ini banyak dibahas pada teknik Masked Language Modeling,
dimana model berusaha untuk melakukan prediksi terhadap kata - kata yang hilang, berdasarkan
kata - kata lain yang mengikutinya.
Selain itu, seperti yang kita bahas sebelumnya bahwa decoder juga dapat menerima data
fitur hasil dari keluaran encoder. Berdasarkan urutan teks yang diberikan, decoder akan melakukan
embedding pada tiap kata yang diberikan, lalu memberikan nomor untuk menandakan posisi kata,
agar decoder mengetahui urutan kata yang diberikan. Sama seperti encoder, selanjutnya kita akan
memberikan Attention Layer, sehingga decoder pun dapat mengetahui bobot dari masing - masing
kata yang diberikan. Setelah itu kita akan melewatkan hasilnya pada feed-forward neural network,
sama seperti yang kita lakukan pada encoder.

153
 Salah satu perbedaan yang mendasar antara encoder dan decoder disini adalah ketika kita
menggunakan attention layer. Pada encoder, kita dapat memberikan seluruh kata - kata yang ada
dalam sebuah kalimat, agar attention layer mendapatkan makna yang terbentuk dari kalimat
tersebut. Namun, pada decoder, kita memberikan kata - kata tersebut satu per satu sesuai urutan
kata dalam kalimat yang sudah dilakukan translasi. Ketika kita akan meminta decoder untuk
melakukan prediksi kata kedua yang mungkin muncul, kita hanya memasukkan kata pertama pada
attention layer. Hal ini mungkin dapat menimbulkan akurasi yang kurang baik, karena kurangnya
informasi yang diberikan. Oleh karena itu, ketika kita menggunakan decoder, umumnya kita
memberikan beberapa kata bantuan (kita sebut teks awal) sebelum mulai melakukan prediksi, agar
mempermudah kerja decoder, dan untuk mendapatkan konteks sesuai yang kita inginkan juga.
Decoder akan melakukan prediksi kata satu per satu, sehingga ketika akan melakukan
prediksi kata ketiga, maka model hanya dapat memperhatikan dua kata sebelumnya yang terbentuk
ketika sampai pada tahap attention layer. Karena proses ini dilakukan secara bertahap, maka ada
pertimbangan bahwa waktu yang dibutuhkan untuk pelatihan akan sangat lama. Oleh karena itu,
untuk mempercepat proses pelatihan, pada decoder, kita akan memberikan seluruh kalimat tersebut
sekaligus, namun ketika kita sampai pada tahap attention layer, layer ini hanya diperbolehkan
untuk melihat kata - kata sesuai dengan urutan kata yang telah dilakukan prediksi saja (dalam kasus
kita akan melakukan prediksi kata ke empat, maka model hanya diperbolehkan untuk melihat 3 kata
sebelumnya saja).
Dengan menggunakan decoder ini, kita dapat menerapkan aplikasi NLP, yaitu Text
Generation, untuk menciptakan kata - kata baru, sesuai konteks teks awal yang kita berikan
sebelumnya. Konsep ini yang membuat kita dapat menciptakan sebuah chatbots, agar mesin dapat
memprediksi jawaban dari apa yang kita tanyakan kepada komputer. Setelah ini, kita akan mencoba
untuk melihat aplikasi decoder ini dengan menggunakan salah satu model Transformers, yaitu
GPT, dengan versi yang dapat kita gunakan secara gratis yaitu GPT2.

154
Studi Kasus : GPT untuk Text Generation

Pada studi kasus ini, kita akan mencoba untuk menggunakan GPT untuk menghasilkan
sebuah teks. GPT sendiri merupakan singkatan dari Generative Pre-training Transformers
(GPT), dimana model ini dapat beradaptasi dan mengerti bahasa manusia, dan juga menghasilkan
sebuah teks baru untuk dapat menjawab pertanyaan dari manusia. Perlu diperhatikan bahwa model
yang akan kita buat ini sangat sederhana, dan apabila ingin digunakan dalam jangkauan lebih luas,
mungkin akan memerlukan referensi lebih dan juga beberapa parameter yang lebih kompleks untuk
dapat menghasilkan sebuah GPT yang lebih baik lagi, seperti yang dilakukan oleh ChatGPT.

Menginstall Library Transformers

Sebelum kita membuat model yang akan kita gunakan untuk mengerjakan Text
Generation, kita akan menginstall dulu library Transformers yang akan digunakan. Kita
menggunakan !pip install Transformers.

Berdasarkan konsep dari decoder yang telah kita bahas sebelumnya, kita akan memasukkan
kata satu per satu dari sebuah kalimat. Dengan konsep ini, kita akan memecah kalimat menjadi
kumpulan kata/token, sehingga kita akan mengambil fungsi tokenizer juga dari Transformers.

Dari model Transformers, kita akan mengambil GPT2Tokenizer untuk membuat token
dari kalimat awal yang nanti akan kita berikan. Kita juga akan menggunakan
GPT2LMHeadModel untuk membuat model Text Generation yang akan kita gunakan nanti.

155
 Nama model yang telah dilatih adalah “gpt2-large” yang sekaligus akan kita gunakan
menjadi basis untuk melatih model kita. Pada saat membuat model, kita juga memberikan
parameter pad_token_id dimana nilai ini sama dengan tokenizer.eos_token_id. Parameter ini
berarti kita akan mengeset dimana tiap batch kata yang diberikan akan memiliki panjang token
yang sama, yaitu sesuai panjang dari kalimat yang diberikan, dan tidak lebih. Eos berarti end-of-
sentence, dimana kita membatasi jumlah pad akan sama dengan jumlah token yang diberikan.

Membuat Model GPT2

Setelah kita membuat tokenizer dan juga model yang akan digunakan untuk menghasilkan
teks, kita akan mulai untuk membuat teks awal. Seperti pada bagian teori yang telah kita bahas
sebelumnya, kita akan menuliskan sebuah teks awal, agar dapat menuntun model GPT2 untuk
menghasilkan kata yang berhubungan dengan teks awal yang kita berikan. Pada contoh kali ini, kita
akan mencoba agar model GPT2 ini dapat menjawab pertanyaan kita mengenai bagaimana cara
membuat sebuah pizza, dalam bahasa inggris akan kita tuliskan : “How to make Pizza?”.
Perhatikan sintaks berikut ini.

Teks awal akan kita tuliskan dalam variabel initial_text. Teks awal ini akan kita ubah
menjadi index token dengan menggunakan tokenizer.encode(), sehingga teks tersebut akan berubah
menjadi angka. Index angka yang diberikan ini merupakan index yang sebelumnya telah ada pada
gpt2-large. Setelah itu, kita akan membuat model kita dengan menuliskan model.generate().
Beberapa parameter yang kita berikan didalamnya adalah input_ids, yang merupakan teks awal
(berbentuk index), lalu kita menuliskan max_length untuk jumlah maksimum karakter yang
dihasilkan.

156
 Num_beams merupakan jumlah maksimal kemungkinan urutan yang dapat dibentuk oleh
fungsi generate. Parameter no_repeat_ngram_size merupakan parameter yang menentukan
jumlah maksimal n-gram yang terbentuk. Early_stopping merupakan parameter yang akan
menghentikan proses generasi teks setelah seluruh teks yang memiliki akurasi tinggi dengan
prediksi initial_text dihasilkan, dimana tujuannya untuk menghindari adanya nilai error pada hasil
generasi teks. Model ini akan kita masukkan pada variabel output.
Ketika kita akan melakukan prediksi, model ini akan mengembalikan angka index dari hasil
prediksi. Untuk mempermudah membacanya, maka kita akan menuliskan tokenizer.decode() untuk
mengembalikannya kedalam sebuah bentuk teks.

Ketika kita akan melihat hasil variabel generated_text, maka kita akan mendapatkan hasil
seperti berikut ini.

Kita melihat bahwa model kita sekarang bisa menghasilkan jawaban atas pertanyaan
bagaimana cara membuat pizza yang kita tanyakan. Walaupun mungkin jawabannya kurang relevan
ataupun masih terlalu umum, kita bisa terus melatih model ini agar memiliki performa yang lebih
baik lagi nantinya dalam memberikan jawaban atas pertanyaan kita.

157
Model Encoder - Decoder / Sequence-to-Sequence (BART)

Model encoder-decoder atau sering disebut sequence-to-sequence ini merupakan model

Transformers secara keseluruhan. Apabila kita lihat kembali skema Transformers, decoder akan
dapat menerima input fitur yang dihasilkan oleh encoder untuk diproses.

Sebagai sebuah model encoder-decoder secara utuh, maka model ini akan mengambil fitur
penting dari sebuah teks (encoder), lalu mencoba untuk membuat ulang sebuah teks (decoder)
sesuai dengan fitur penting tersebut. Dengan konsep seperti ini, maka model encoder-decoder atau
sequence-to-sequence generator ini cocok untuk digunakan pada model Question-Answering,
dimana model dapat menjawab pertanyaan yang kita berikan, sekaligus mencoba untuk melakukan
translasi bahasa dari satu bahasa ke bahasa yang lainnya. Selain itu, dengan model tersebut, karena
model akan mengambil fitur penting dari sebuah teks input dan mencoba membuat kembali teks
berdasarkan fitur tersebut, maka kita bisa menggunakan model untuk menarik kesimpulan dari
sebuah kalimat. Aplikasi ini biasa sering disebut sebagai Text Summarization, dimana model
berusaha untuk mengambil kesimpulan dari sebuah teks yang panjang.

158
 Bi-directional and Auto-Regressive Transformers (BART) merupakan salah satu model
Autoencoder yang ditujukan untuk menghilangkan noise pada data teks. Dengan ini, sebuah model
BART yang telah dilakukan fine tuning dapat menerima sebuah kata berurutan (misalkan dalam
bahasa Inggris) lalu menghasilkan kata berurutan kembali (misalkan dalam bahasa Indonesia),
Question-Answering (menghasilkan jawaban atas sebuah pertanyaan), Text Summarization
(untuk menghasilkan sebuah kesimpulan dari sebuah kalimat), ataupun klasifikasi berurutan dari
sebuah kata. Karena bertujuan untuk menghilangkan noise pada data teks, maka BART dilatih
dengan mengikutsertakan data “kotor” dan penuh “noise”. Sama seperti aplikasi Autoencoder yang
kita bahas pada materi Bab 4E - Deep Learning dan Bab 5 - Computer Vision, autoencoder pada
BART bertujuan untuk meningkatkan kualitas dari data yang memiliki noise tersebut.

Studi Kasus : BART untuk Text Summarization

Kita akan mencoba untuk membuat sebuah Text Summarization dengan menggunakan
BART untuk menyimpulkan inti dari sebuah artikel yang kita dapat dari BBC News. Sebelum kita
membuat model BART, seperti pada model Transformers sebelumnya, kita akan menginstall
library Transformers terlebih dahulu pada Google Colab.

Menginstall Library Transformers

Kita akan menuliskan !pip install transformers untuk menginstall library Transformers
yang akan kita gunakan. Setelah kita menginstall library Transformers ini, kita kan mulai untuk
membuat model BART kita.

159
Membuat Model BART

Untuk membuat model BART, kita kan memanggil beberapa fungsi yang akan kita gunakan
seperti BartForConditionalGeneration untuk membuat model dan BartTokenizer untuk
membuat teks menjadi sebuah token. Model yang telah dilatih yang akan kita gunakan adalah
“facebook/bart-large-cnn”. Kita akan memasukan fungsi BartTokenizer kedalam variabel
tokenizer dengan menggunakan model yang kita tuliskan sebelumnya. Kita juga akan membuat
model BART dengan memasukkan fungsi BartForConditionalGeneration ke dalam variabel
model dengan menggunakan model yang telah dilatih sebelumnya.
Setelah kita membuat masing - masing variabel tokenizer dan juga variabel model kita, kita
akan menuliskan teks yang akan kita rangkum dengan menggunakan model kita. Teks ini diambil
dari isi berita dari BBC News, dan kita hanya mengambil isi beritanya saja. Perhatikan gambar
berikut ini.

160
 Agar lebih mudah mencerna konteks dari berita tersebut, inti dari berita tersebut adalah
bahwa negara China melarang pekerjanya untuk menggunakan produk Apple, dimana ini
menyebabkan nilai saham Apple turun dalam kurun waktu dua hari beruntun. Dengan
menggunakan model BART ini, kita akan mencoba mencari tahu apakah model tersebut dapat
mengeluarkan kesimpulan dari berita tersebut sesuai, atau minimal mendekati konteks yang sedang
kita bicarakan. Kita akan menggunakan encoding() untuk membuat seluruh input_text menjadi
numerik terlebih dahulu. Setelah itu, kita akan mencoba untuk melakukan proses generasi teks.

Setelah model kita menghasilkan hasil rangkuman pada variabel summary_ids, kita akan
mencoba untuk melakukan decoding, untuk mengubahnya kembali dari numerik menjadi teks agar
lebih mudah dibaca.

Ketika kita mencoba untuk memunculkan hasil teks rangkuman, kita mendapatkan hasil
berikut ini :

BART Summary:
China is the technology giant's third-largest market, accounting for 18% of its total revenue last
year. Most of Apple's products are manufactured by its biggest supplier Foxconn. The Wall Street
Journal reported that Beijing had ordered central government agency officials to not bring iPhones
into the office or use them for work.

Apabila kita melihat hasil rangkuman yang dilakukan, kita lihat bahwa sebagian besar teks
atau kalimat yang terbentuk merupakan hasil cuplikan dari beberapa teks input yang diberikan.
Namun dapat kita perhatikan disini bahwa apabila kita mengartikan teks yang dihasilkan dari teks
rangkuman tersebut,
161
kita memahami bahwa teks yang terbentuk tersebut merupakan inti dan kesimpulan dari
keseluruhan konteks yang diceritakan oleh berita BBC News tersebut. Pada berita tersebut, kita
mengetahui bahwa inti ceritanya adalah bahwa Pemerintah China melarang penggunaan produk
Apple. Model BART yang kita buat berhasil untuk menangkap inti dari berita tersebut, dan
menampilkan beberapa kalimat saja sebagai rangkuman, yang mencerminkan inti dari berita
tersebut.

Intermezzo:
Aplikasi dari NLP

Natural Language Processing (NLP) memiliki manfaat yang sangat besar,

karena kita manusia umumnya menggunakan bahasa dalam berkomunikasi setiap
harinya. Tiap komunikasi yang kita lakukan berisikan informasi yang dapat
menjadi data. Informasi yang terkumpul tersebut dapat digunakan untuk
mendapatkan sebuah insight yang dapat berguna bagi kehidupan manusia.

Berdasarkan fungsi dan tujuan yang ingin dicapai, kita memiliki beberapa fitur
NLP yang dapat diterapkan dengan menggunakan data, seperti Text
Classification untuk mengelompokkan teks, lalu Sentiment Analysis untuk
menentukan emosi dari sebuah kalimat, ada juga Topic Modeling dimana kita
bisa menentukan tema dari sebuah percakapan ataupun kalimat. Selain itu,
dengan penggunaan Deep Learning, maka kita bisa meningkatkan performansi
dari NLP sehingga dapat membuat sebuah model yang dapat menghasilkan
sebuah teks berdasarkan kalimat yang diberikan (Text Generation).

Dengan ditemukannya arsitektur Transformers sejak tahun 2017, hal ini

membuat komputer dapat berkomunikasi dengan manusia dengan menggunakan
bahasa natural. Hal ini yang menjadi terobosan baru dimana terciptanya Text
Translation seperti BERT, GPT, dan BART, dimana komputer dapat
berkomunikasi dengan manusia dan menjawab pertanyaan manusia.

162
 Kesimpulan
Natural Language Processing (NLP) adalah teknik yang dapat digunakan untuk mengolah data
berbentuk teks dengan algoritma - algoritma Machine Learning yang sudah kita kenal sebelumnya.
Walaupun kita tahu bahwa beberapa algoritma Machine Learning menggunakan rumus matematika,
namun dengan beberapa teknik yang kita miliki menggunakan NLP, kita dapat mengubah sementara data
teks tersebut menjadi sebuah data angka yang dapat kita olah dengan menggunakan algoritma Machine
Learning. Kita juga dapat menerapkan algoritma Deep Learning didalamnya untuk mendapatkan hasil
yang lebih baik dan performa model yang lebih akurat lagi.
NLP ini memiliki aplikasi yang luas dan sangat berguna untuk mendukung kehidupan manusia,
karena manusia pada umumnya sehari - hari berkomunikasi dengan menggunakan bahasa antara satu sama
lain, sehingga dengan diajarkannya sebuah mesin untuk mengerti bahasa manusia, maka mesin tersebut
dapat membantu manusia untuk menyelesaikan urusan yang mungkin sulit untuk dilakukan oleh manusia
sendiri. Beberapa aplikasi dari NLP yang mungkin telah kita kenal sekarang ini adalah seperti voice
recognition dan juga ChatGPT.

163
 Exercise
Cobalah untuk menjawab pertanyaan berikut ini berdasarkan yang telah kamu pelajari
pada bab ini

1. Sebutkan 5 aplikasi dari NLP yang dapat digunakan untuk mendukung kehidupan
manusia.
2. Mengapa kita harus melakukan proses Count Vectorization sebelum kita
melakukan pengolahan data teks? Jelaskan!

3. Perhatikan data berikut ini yang diambil dari situs kaggle. Data tersebut berisikan
data twitter hasil komentar banyak orang mengenai aplikasi ChatGPT beserta
dengan hasil sentimen yang dihasilkan. Berdasarkan data tersebut, buatlah sebuah
model sederhana yang dapat menentukan sentimen dari kalimat baru yang
mungkin nanti dapat muncul apabila ada data baru yang masuk.

164