MACHINE LEARNING

DENGAN PYTHON
Dengan Contoh Pengaplikasian di Bidang Medis

Hanna Arini Parhusip

Penerbit ANDI
 PRAKATA

S
ebagai pengguna Machine Learning sejak tahun 2020 maka buku yang berjudul Machine
Learning dengan Python – Dengan Contoh Pengaplikasian di Bidang Medis ini dapat
menjadi contoh sederhana bagi para pemula dalam melakukan coding dan analisis
data dengan Python. Buku ini disusun untuk para pemula agar mempunyai pemahaman yang
cukup dan dapat bekerja dengan Machine Learning. Adanya berbagai informasi dari internet
dan YouTube terkait Machine Learning dapat melengkapi pengetahuan yang diperlukan dalam
buku ini.
Buku ini ditulis sebagai kegiatan bersama dengan mahasiswa dalam mempelajari
Machine Learning sehingga materi yang dituliskan juga merupakan bentuk latihan bersama
dengan mahasiswa. Selain itu, materi penulisan dibuat dalam masa pandemi, yaitu tahun
2020-2022. Hal ini menyebabkan salah satu bab, yaitu Bab IV diperuntukkan sebagai bukti
kontribusi penulis dalam melakukan penelitian terkait Covid-19. Oleh karena itu, diharapkan
pembaca juga dapat menggunakan materi buku ini sebagai sumber belajar, khususnya dalam
penelitian pengolahan data Covid-19 dengan Machine Learning.
DAFTAR ISI

PRAKATA................................................................................................................................ iii

DAFTAR ISI............................................................................................................................. iv

DAFTAR TABEL .................................................................................................................... vii

DAFTAR GAMBAR ............................................................................................................... viii

BAB 1 PENGENALAN PEMBELAJARAN MESIN (MACHINE LEARNING)

UNTUK ANALISIS DATA ............................................................................................ 1
1.1 Apa Itu Machine Learning? ................................................................................. 1
1.2 Kapan Memerlukan Mesin Pembelajaran (Machine Learning)? ......................... 4
1.3 Kompleksitas dengan Bidang Lain...................................................................... 5
1.4 Cara Kerja Machine Learning ............................................................................. 5
1.4.1 Pembelajaran Terbimbing (Supervised Learning/SL) ................................ 6
1.4.2 Contoh-Contoh Penggunaan Machine Learning ..................................... 10
1.4.3 Pembelajaran Mesin tak Terbimbing (Unsupervised Machine
Learning/UML) ..........................................................................................11
1.4.4 Semi Mesin Pembelajaran Terbimbing (Semi-Supervised Machine
Learning/SSML)........................................................................................11
1.5 Langkah-Langkah Pengolahan Data dalam Machine Learning ........................ 12
1.5.1 Proses Teknis Lebih Lanjut...................................................................... 13
1.5.2 Pemilihan Model ...................................................................................... 14
1.5.3 Mengevaluasi Model................................................................................ 14
1.6 Penggunaan ML dengan Python ...................................................................... 14
1.6.1 Pemisahan dengan Scikit Learn .............................................................. 15
1.6.2 Validasi Silang (K-cross Validation) ......................................................... 15
1.6.3 Proses Pemodelan Data yang Sudah Bersih .......................................... 16
1.7 Overfitting dan Underfitting ............................................................................... 16
1.8 Algoritma KNN (K-Nearest Neighbors) ............................................................. 36
1.9 Metode Klasifikasi Bayes Naif (Naive Bayes Classification) ............................. 41
1.9.1 Penggunaan Bayes pada Industri ........................................................... 45
1.9.2 Navier Bayes Classifier (NBC) dengan Python ....................................... 46
RINGKASAN BAB 1 ............................................................................................................... 57
DAFTAR PUSTAKA ................................................................................................................ 57
 DaŌar Isi v

BAB 2 METODE KLASTER BERDASARKAN PUSAT ........................................................ 59

2.1 Pendahuluan ..................................................................................................... 59
2.2 K-Means dengan Python .................................................................................. 62
2.2.1 Pemilihan Banyaknya Klaster .................................................................. 62
2.3 Contoh Pemrograman K-Means Clustering ...................................................... 63
2.3.1 Dengan Daftar Data dalam 2 Klaster....................................................... 63
2.3.2 Dengan Daftar Data dalam 4 Klaster....................................................... 82
2.3.3 K-Means Clustering dengan Membangkitkan Data ................................. 84
2.4 Variasi dari Algoritma K-Means ......................................................................... 89
2.4.1 Algoritma K-Means Kontinu ..................................................................... 89
2.4.2 Algoritma Pembandingan Rata-Rata ....................................................... 90
2.4.3 Algoritma Pengurutan Rata-Rata ............................................................ 90
2.4.4 Algoritma E-M .......................................................................................... 90
2.5 Kelemahan Lain K-Means Clustering ............................................................... 91
2.5.1 Menggunakan Python untuk Kasus Batas Data tidak Linear .................. 91
DAFTAR PUSTAKA ................................................................................................................ 94

BAB 3 NATURAL LANGUAGE PROCESS (NLP): MACHINE LEARNING

UNTUK DATA TEKS ................................................................................................. 95
3.1 Prinsip Kerja NLP.............................................................................................. 95
3.1.1 Library Penting yang Digunakan dalam Pemrosesan Bahasa
pada Python ............................................................................................ 98
3.1.2 Corpus dan Data Teks ............................................................................. 99
3.2 Klasifikasi Teks dengan Algoritma NLP........................................................... 105
3.2.1 Konversi Huruf Kecil .............................................................................. 107
3.2.2 Klasifikasi Teks dari Amazon Review .....................................................110
3.3 Klasifikasi Spam Non-spam dengan Naive Bayes ...........................................117
3.3.1 Program Python untuk Klasifiaksi Spam dan Non-spam ........................119
3.4 Klasifikasi dengan WordCloud ........................................................................ 184
3.4.1 Melakukan Vektorisasi Token ................................................................ 185
DAFTAR PUSTAKA .............................................................................................................. 208

BAB 4 PENGANTAR SUPPORT VECTOR MACHINE (SVM) .......................................... 209

4.1 Pendahuluan ................................................................................................... 209
4.1.1 Tujuan SVM ........................................................................................... 209
4.1.2 Apakah Bidang (Hyperplane) Pemisah? ............................................... 210
4.1.3 Mengapa Diberi Nama Hyperplane? ......................................................211
4.1.4 Apakah Margin dalam SVM Menentukan Optimal Hyperplane
yang Terbaik? ........................................................................................ 212
4.1.5 Margin A Lebih Besar daripada Margin B .............................................. 213
4.1.6 Bagaimana Menghitung Margin?........................................................... 213
4.1.7 Proyeksi Ortogonal Suatu Vektor .......................................................... 216
vi Machine Learning dengan Python

4.2 Bagaimana SVM Dibuat?................................................................................ 218

4.2.1 Hitung Margin Hyperplane ..................................................................... 222
4.3 Masalah Optimasi SVM dengan Metode Lagrange ........................................ 234
4.3.1 Keuntungan Algoritma SVM .................................................................. 238
4.3.2 Kerugian Algoritma SVM ........................................................................ 238
4.4 Apa yang Dilakukan Jika Pengali Lagrange Sudah Ada? ............................... 239
4.4.1 Hitung w................................................................................................. 239
4.4.2 SVM dengan Solver QP ........................................................................ 239
4.4.3 Masalah dengan Data Mempunyai Derau ............................................. 241
4.4.4 Bagaimana Perilaku c?.......................................................................... 243
4.4.5 Perumusan Lain Soft Margin ................................................................. 244
4.5 Bagaimana Mengklasifikasi Data yang Terpisah tidak Linear? ....................... 244
4.5.1 Bagaimana Kita Tahu Transformasi Apa yang Bisa Digunakan? .......... 246
4.6 Kernel.............................................................................................................. 247
4.6.1 Tipe Kernel ............................................................................................ 249
DAFTAR PUSTAKA .............................................................................................................. 251

BAB 5 POHON KEPUTUSAN (DECISION TREE/DT) ...................................................... 253

5.1 Sejarah dan Pengertian Umum Confusion Matrix........................................... 253
5.2 Confusion Matrix (CM) .................................................................................... 255
5.3 Pendahuluan Pohon Keputusan ..................................................................... 258
5.3.1 Cara Kerja Decision Tree ...................................................................... 259
5.3.2 Implementasi DT dengan Scikit Learn Python untuk Cek Keaslian
Uang Kertas........................................................................................... 264
5.3.3 Membuat Code Decision Tree dari Awal ............................................... 274
5.3.4 Analisis Lebih Lanjut dengan Decision Tree.......................................... 279
5.4 Random Forest ............................................................................................... 280
DAFTAR PUSTAKA .............................................................................................................. 284

BAB 6 MACHINE LEARNING UNTUK KASUS COVID-19 ............................................... 285

6.1 Data Covid-19 di Salatiga pada 30 Maret-7 November 2020
Kasus Sederhana ........................................................................................... 286
6.2 Machine Learning Data Kasus Covid-19 Indonesia ........................................ 293
6.3 Klasterisasi Data Covid-19 di Indonesia ......................................................... 323
6.4 Data Covid-19 Dunia....................................................................................... 327
6.5 Penutup........................................................................................................... 342
DAFTAR PUSTAKA .............................................................................................................. 343

INDEKS ................................................................................................................................ 344

TENTANG PENULIS ............................................................................................................ 348

 DAFTAR TABEL

Tabel 1.1 Daftar SL dalam Bahasa Inggris dan Bahasa Indonesia

Tabel 1.2 Daftar SL dalam Bahasa Inggris dan Bahasa Indonesia Tingkat Lanjut
Tabel 1.3 Contoh Data yang Dianalisis Hasil Observasi oleh National Institute of Diabetes
and Digestive and Kidney Diseases terhadap 768 Wanita
 DAFTAR GAMBAR

Gambar 1.1 Bagan proses Machine Learning

Gambar 1.2 Partisi data dengan K=3 kali partisi
Gambar 1.3 Ilustrasi underfitting (kiri), overfitting (kanan), dan fitting yang tepat (tengah)
Gambar 1.4 Distribusi data pasien yang berlabel 0 (tidak diabetes)
Gambar 1.5 Distribusi data pasien yang berlabel 1 (diabetes)
Gambar 2.1 Ilustrasi pusat klaster terhadap anggota yang lain pada K-Means
Gambar 2.2 Ilustrasi pusat klaster dan pemisahan pada iterasi tertentu terhadap anggota
yang lain pada K-Means
Gambar 2.3 Iterasi metode Elbow terhadap nilai WCSS yang menunjukkan konvergensi
Gambar 2.4 Klaster mula-mula (kiri) dan hasil klaster (kanan) pada K-Means
Gambar 2.5 Penampilan data yang akan di klaster
Gambar 2.6 Penampilan data yang akan di klaster dan pusat klaster pada awal iterasi
Gambar 2.7 Penampilan data yang akan di klaster dan pusat klaster pada awal selanjutnya
setelah proses dengan hasil Gambar 2.6
Gambar 2.8 Penampilan data yang akan di klaster yang mengelompok pada 2 lokasi
Gambar 2.9 Penampilan data yang akan di klaster yang mengelompok pada 2 lokasi serta
penentuan titik pusat klaster
Gambar 2.10 Penampilan data yang akan di klaster dengan pusat klaster yang diletakkan
random untuk kasus Contoh 2.3
Gambar 3.1 Prinsip kerja NLP
Gambar 3.2 Contoh Komunitas Python di Telegram
Gambar 3.3 Corpus Othelo
Gambar 3.4 Memanggil Jupyter Notebook
Gambar 3.5 Tampilan Homepage Jupyter
Gambar 3.6 Tampilan Homepage Jupyter
Gambar 3.7 Proses awal membuka Jupyter Notebook
Gambar 3.8 Tampilan teks di dalam Corpus Othello.txt yang berhasil dipanggil
Gambar 3.9 Hasil penelusuran Corpus
Gambar 3.10 Hasil penelusuran Corpus
Gambar 3.11 Hasil contoh Corpus
 DaŌar Gambar ix

Gambar 3.12 Hasil konversi huruf kecil

Gambar 3.13 Hasil konversi huruf kecil untuk teks
Gambar 3.14 Hasil tampilan dataset spam
Gambar 4.1 Ilustrasi data berlabel
Gambar 4.2 Ilustrasi contoh garis pemisah yang mungkin
Gambar 4.3 Ilustrasi margin
Gambar 4.4 Contoh penampilan vektor dari O ke A(3,4)
Gambar 4.5 Ilustrasi vektor u dengan sudut yang dibentuk
Gambar 4.6 Sudut yang dibentuk antara 2 vektor
Gambar 4.7 Sudut yang dibentuk antara 2 vektor dan vektor yang diproyeksikan
Gambar 4.8 Hubungan vektor yang diproyeksikan dan proyeksinya
Gambar 4.9 Ilustrasi selisih antara 2 vektor
Gambar 4.10 Ilustrasi pemisahan data dengan SVM
Gambar 4.11 Ilustrasi pemisahan data dengan SVM lanjutan
Gambar 4.12 Ilustrasi pemisahan data dengan vektor yang diproyeksikan serta hyperplane
yang diperoleh
Gambar 4.13 Ilustrasi pemisahan data dengan vektor yang diproyeksikan serta hyperplane
yang diperoleh dan vektor hasil proyeksi
Gambar 4.14 Yang menyediakan hyperplane
Gambar 4.15 Ilustrasi hyperplane
Gambar 4.16 Data terpisah linear (kiri) dan terpisah tidak linear (kanan)
Gambar 4.17 Ilustrasi w.x-b=-1 dan w.x-b =1
Gambar 4.18 Jenis hyperplane yang berbeda-beda
Gambar 4.19 Jenis hyperplane yang tidak benar
Gambar 4.20 Ilustrasi margin sepanjang m pada hyperplane
Gambar 4.21 Ilustrasi margin sepanjang m pada hyperplane dengan jarak yang dimungkinkan
Gambar 4.22 Ilustrasi margin sepanjang m antar-hyperplane yang dimungkinkan
Gambar 4.23 Ilustrasi margin sepanjang m pada hyperplane vektor u yang tegak lurus pada
hyperplane
Gambar 4.24 Ilustrasi vektor k sepanjang m yang searah u pada hyperplane yang tegak
lurus pada hyperplane
Gambar 4.25 Ilustrasi vektor k, zo = xo. + k dan xo pada hyperplane
Gambar 4.26 Ilustrasi data memuat outlier pada posisi (7,8)
Gambar 4.27 Ilustrasi data terklasifikasi linear
Gambar 4.28 Ilustrasi data terklasifikasi tidak linear
x Machine Learning dengan Python

Gambar 4.29 Data masih tidak terpisah secara linear pada ruang 3 dimensi
Gambar 4.30 Ilustrasi SVM dengan pemisahan data tak linear
Gambar 5.1 Contoh struktur pohon keputusan (decision tree)
Gambar 5.2 Bola dengan warna sama dan berbeda
Gambar 5.3 Sketsa decision tree yang diperoleh (hasil kode penulisan tidak cukup jelas)
Gambar 6.1 Tampilan data kasus Covid-19 di Salatiga untuk fitur ‘Suspek (rentan)’ pada
periode 30 Maret-7 November 2020
Gambar 6.2 Tampilan data kasus Covid-19 di Salatiga untuk fitur ‘Terkonfirmasi’ pada
periode 30 Maret-7 November 2020
Gambar 6.3 Tampilan data kasus Covid-19 di Salatiga untuk fitur ‘Terkonfirmasi’ pada
periode 30 Maret-7 November 2020
Gambar 6.4 Tampilan data kasus Covid-19 di Salatiga untuk fitur ‘Terkonfirmasi’, ‘Sembuh’,
dan ‘Meninggal’ pada periode 30 Maret-7 November 2020
Gambar 6.5 Tampilan data kasus Covid-19 di Salatiga untuk fitur ‘Meninggal’ pada periode
30 Maret-7 November 2020
Gambar 6.6 Tampilan data kasus Covid-19 di Salatiga untuk fitur ‘Meninggal’ pada periode
30 Maret-7 November 2020
Gambar 6.7 Tampilan data yang akan diolah (kasus Covid-19 hingga 2 Desember 2021)
sebanyak 21759 rows × 38 columns
Gambar 6.8 Kasus aktif untuk Indonesia pada periode Maret-Desember 2021 pada sumbu
horizontal tanggal (ditulis Date) dan banyaknya kasus (sumbu vertikal)
Gambar 6.9 Kasus selesai (meninggal atau sembuh) untuk Indonesia pada periode Maret-
Desember 2021 pada sumbu horizontal tanggal (ditulis Date) dan banyaknya
kasus (sumbu = vertikal)
Gambar 6.10 Kasus pertumbuhan mingguan untuk Indonesia pada periode Maret-Desember
2021 pada sumbu horizontal dan banyaknya kasus (sumbu = vertikal)
Gambar 6.11 Kasus pertumbuhan mingguan total kasus untuk Indonesia periode Maret-
Desember 2021 pada sumbu horizontal dan banyaknya kasus (sumbu =
vertikal)
Gambar 6.12 Kasus pertumbuhan mingguan kasus kematian untuk Indonesia periode Maret-
Desember 2021 pada sumbu horizontal dan banyaknya kasus (sumbu vertikal)
Gambar 6.13 Kasus pertumbuhan kasus kematian, sembuh, total kasus untuk Indonesia
periode Maret-Desember 2021 pada sumbu horizontal dan banyaknya kasus
(sumbu vertikal)
Gambar 6.14 Kasus pertumbuhan harian kasus kematian, sembuh, total kasus untuk
Indonesia periode Maret-Desember 2021 pada sumbu horizontal dan
banyaknya kasus (sumbu vertikal)
 DaŌar Gambar xi

Gambar 6.15 Lokasi 10 terbanyak untuk total kasus Covid-19 di Indonesia periode Maret
2021-Oktober 2021
Gambar 6.16 Lokasi 10 terbanyak untuk total kasus sembuh Covid-19 di Indonesia periode
Maret 2021-Oktober 2021
Gambar 6.17 Lokasi 10 terbanyak untuk total kasus kematian Covid-19 di Indonesia periode
Maret 2021-Oktober 2021
Gambar 6.18 Lokasi 10 terbanyak untuk total kasus Covid-19 pada 24 jam terakhir di
Indonesia periode Maret 2021-Oktober 2021
Gambar 6.19 Lokasi 10 terbanyak untuk total kasus sembuh Covid-19 pada 24 jam terakhir
di Indonesia periode Maret 2021-Oktober 2021
Gambar 6.20 Lokasi 10 terbanyak untuk total kasus kematian Covid-19 pada 24 jam terakhir
di Indonesia periode Maret 2021-Oktober 2021
Gambar 6.21 Lokasi 10 provinsi terbanyak untuk total kasus aktif Covid-19 di Indonesia
periode Maret 2021-Oktober 2021
Gambar 6.22 Lokasi 10 provinsi terbanyak untuk total kasus selesai (mati/sembuh) Covid-19
di Indonesia periode Maret 2021-Oktober 2021
Gambar 6.23 Hasil model Elbow pada klasterisasi K-means data kematian dan sembuh
kasus Covid-19 di Indonesia periode Maret 2021-Oktober 2021
Gambar 6.24 Hasil klasterisasi hierarki data kematian dan sembuh kasus Covid-19 di
Indonesia periode Maret 2021-Oktober 2021
Gambar 6.25 Klasifikasi data kasus Covid-19 antara kematian dan sembuh dalam kelompok
provinsi dalam 3 kluster dengan memperhatikan rata-rata tingkat sembuh dan
rata-rata tiap kematian
Gambar 6.26 Daftar tanggal pada data yang diolah
Gambar 6.27 Contoh tampilan yang terkonfirmasi dari 5 baris pertama (‘confirmed’) data
yang diolah
Gambar 6.28 Hasil pendataan yang didaftar dengan melakukan running program pada
tanggal 16 Juli 2022 maka tercatat data hingga 15 Juli 2022
Gambar 6.29 Visualisasi prediksi linear dan data uji dengan kasus yang terkonfirmasi data
kasus Covid-19 dunia sejak Januari 2020 hingga Maret 2020
Gambar 6.30 Visualisasi prediksi model Bayesian terhadap data uji dengan kasus yang
terkonfirmasi data kasus Covid-19 dunia
BAB 1
PENGENALAN PEMBELAJARAN
MESIN (MACHINE LEARNING)
UNTUK ANALISIS DATA

1.1. Apa Itu Machine Learning?

Machine Learning (ML) diterjemahkan sebagai mesin pembelajaran pada buku ini adalah
bagian dari ilmu komputer yang meliputi studi tentang pengenalan pola data dan teori komputasi
dalam inteligensi buatan (Artificial Intelligence) (Guégan & Hassani, 2018) (Dönmez, 2013).
ML melakukan konstruksi dan studi algoritma yang mempelajari dari dan membuat prediksi
data. Algoritma demikian membangun model dari contoh input yang ada untuk membuat
keputusan atau prediksi yang dibangun data di mana program statis pada umumnya hanya
mengikuti instruksi program. Sering kali pula ML berkaitan dan beririsan dengan statistika
komputasi di mana statistika komputasi juga mengkhususkan pada pembuatan prediksi yang
terkait erat dengan optimasi matematika yang membangun teori, metode, dan aplikasi terkait
domain. Demikian pula ML, juga sering terkait dengan data mining di mana data mining lebih
mengeksplorasi analisis data. Salah satu contoh adalah eksplorasi data dari data sensor
pada daerah eksplorasi mineral di mana metode pembelajaran mesin (ML) dapat membantu
memproses berbagai kumpulan data penginderaan jauh dan menentukan hubungan
antarkomponen seperti kontinum pantulan dan fitur yang menarik (Shirmard et al., 2022).
Ketika ML digunakan pada industry, ML lebih dikenal sebagai prediksi model atau analisis
prediksi.
Pada tahun 1959 disebutkan oleh Arthur Samuel, bahwa ML sebagai suatu studi yang
memberikan komputer untuk mempelajari sendiri tanpa secara eksplisit diprogram di mana
hal ini mendefinisikan ML lebih operasional secara fundamental dibandingkan kognitif. Lebih
2 Machine Learning dengan Python

mudahnya dengan pertanyaan berikut: dapatkah mesin melakukan apa yang kita pikirkan?
Pada tahun 2006, Tom Michell juga menegaskan bahwa ML sebagai irisan dari Ilmu Komputer
dan Statistik. Pada ilmu komputer lebih memfokuskan bagaimana komputer diprogram,
sedangkan pada ML memfokuskan pada bagaimana komputer memprogram sendiri dengan
diberikan struktur awal. Demikian pula, statistik memfokuskan pada kesimpulan yang dapat
di inferensi dari data, sedangkan ML menambahkan pada pertanyaan tentang bagaimana
arsitektur komputasi dan algoritma dapat digunakan secara paling efektif, penggabungan
data, bagaimana mempelajari subtugas (multitasking) yang dapat disusun dalam sistem yang
lebih besar; ML juga menjawab pertanyaan tentang penelusuran komputasi (Mohammed et
al., 2017).
Contoh sederhana berikut memberikan motivasi bagaimana algoritma dibangun. Misalkan
kawanan tikus mencari makanan dan menemukan secara tiba-tiba dengan kelihatan bagus dan
menarik maka tikus akan memakannya sedikit demi sedikit. Jika makanan terasa enak maka
tikus akan melanjutkan makan. Jika tikus merasakan makanan tidak enak maka makanan tidak
dimakan. Jika makanan memuat racun dimakan tikus maka pada periode tertentu tikus tidak
mencari makanan pada lokasi di mana makanan tikus diperoleh. Ada proses pembelajaran
secara natural di mana tikus dapat mengenali bahwa makanan pada lokasi yang sama beracun
sehingga tidak datang pada lokasi tersebut untuk periode tertentu.
Diinspirasi oleh sifat natural tersebut, misalkan kita dapat membangun algoritma untuk
mengoleksi e-mail yang tergolong spam. Mesin akan mengingat bagaimana berdasarkan
pengetahuan sebelumnya bahwa e-mail dikatakan spam oleh pengguna maka email yang
datang selanjutnya dapat tergolong spam dan bukan spam. Jadi pendekatan cara kerja
demikian dikatakan ‘pembelajaran karena pengingat’. Hal ini mempunyai kekurangan dalam
aspek pembelajaran, yaitu kemampuan memberi label pada pesan e-mail yang tidak terlihat.
Suatu pembelajaran berhasil jika dapat melakukan kemajuan secara individu dalam melakukan
perumuman yang lebih luas. Untuk mencapai perumuman dalam tugas melakukan filterisasi
e-mail pada spam, pembelajar dapat menelusuri e-mail-e-mail yang sebelumnya dilihat dan
melakukan ekstraksi kata-kata dalam pesan yang terindikasi spam. Ketika e-mail baru datang,
mesin dapat menguji apakah kata-kata dalam e-mail tersebut sebagai spam dan menduga
labelnya. Sistem yang demikian dapat menduga secara benar pelabelan dalam e-mail-e-mail
yang tidak terlihat. Cara seperti ini disebut cara berpikir induktif. Akan tetapi, cara induktif ini
bisa selalu benar sebagaimana dijelaskan pada kasus perilaku merpati berikut.
Kasus tersebut dikenal sebagai Pigeon Superstition. Seorang tokoh psikolog pada
bidang perilaku dari Amerika menempatkan sekumpulan burung merpati dalam suatu sangkar.
 Pengenalan Pembelajaran Mesin (Machine Learning) untuk Analisis Data 3

Mekanisme otomatis dilakukan, yaitu mengirimkan makanan dalam sangkar pada interval
waktu tertentu tanpa memperhatikan perilaku burung-burung tersebut sebelumnya. Burung-
burung tersebut makan pada makanan yang pertama kali dikirimkan dan setiap burung
melakukan beberapa aktivitas (mengambil makanan, memutar kepala, dan seterusnya).
Setiap awal pengiriman makanan, setiap burung melakukan aksi spesifik dan akibatnya
setiap burung cenderung memerlukan waktu untuk melakukan aksi yang sama. Kemudian,
perubahan pengiriman makanan dilakukan secara random, setiap burung melakukan hal yang
sama, pada saat awal bagaimana makanan dikirimkan. Hal ini dilakukan dengan disiplin oleh
burung-burung itu. Video yang terkait dengan penjelasan Skinner dijelaskan pada YouTube
(https://yout.com/video/QKSvu3mj-14/). Pada video ditunjukkan bagaimana burung dalam
eksperimen diberi makan pada awal dengan suara pemberian makan tertentu. Jika pemberian
makan diberi kode dengan cahaya maka burung tidak menunjukkan perilaku mengambil
makanannya. Pada video serupa, seorang anak diberi makanan dari suatu meja. Jika meja
ditinggikan, anak tersebut secara otomatis mengambil kursinya untuk dapat meraih makanan
yang semula terjangkau, tetapi menjadi tidak terjangkau.
Mekanisme pembelajaran apa yang membedakan antara perilaku burung dengan
pembelajar pada manusia? Hal ini merupakan pertanyaan krusial dalam pengembangan
pembelajar otomatis. Pembelajar manusia dapat bersandar pada common sense (pemahaman
umum) untuk melakukan filter terhadap pembelajaran yang tidak bermakna secara random.
Jika kita sudah menyerahkan tugas demikian pada mesin, kita harus membuat prinsip crisp
(pengodean) yang baik yang akan melindungi program dari pencapaian kesimpulan yang tidak
bermakna. Pengembangan prinsip demikian merupakan pusat teori dari mesin pembelajaran
(machine learning). Yang menjadi masalah: mengapa pada tikus berhasil menggunakan
induksi, sedangkan pada burung merpati tidak bisa berlaku? Hal inilah yang dipelajari dalam
ML. Perbedaan keduanya inilah yang membuat bias dalam mekanisme pembelajaran dan juga
bias dalam induksi.
Machine learning atau pembelajaran mesin adalah ilmu atau studi yang mempelajari
tentang algoritma dan model statistik yang digunakan oleh sistem komputer untuk melakukan
tugas tertentu tanpa instruksi eksplisit. Machine learning bergantung pada pola dan kesimpulan.
Untuk mendapatkan pola dan kesimpulan tersebut, algoritma Machine learning menghasilkan
model matematika yang didasari dari data (Ghada et al., 2020)we present the most recent
breast cancer detection and classification models that are machine learning based models
by analyzing them in the form of comparative study. Also, in this paper, the datasets that are
public for use and popular as well are listed in the recent work to facilitate any new experiments
4 Machine Learning dengan Python

and comparisons. The comparative analysis shows that the recent highest accuracy models
based on simple detection and the classification architectures are You Only Look Once (YOLO.
Misalkan untuk mempelajari kanker payudara maka diambil sampel data penderita kanker
payudara yang sering disebut dengan ‘training data’.
Pembelajaran mesin digolongkan sebagai aplikasi kecerdasan buatan yang mampu
menyediakan sistem secara otomatis untuk mempelajari dan memperbaiki dari pengalaman
tanpa secara eksplisit deprogram. Pembelajaran mesin fokus pada perkembangan komputer
program yang dapat mengakses data dan menggunakannya untuk dirinya sendiri. Proses
pembelajaran dimulai dari mengobservasi data langsung dari pengamanan atau berdasarkan
instruksi untuk melihat pola data dan membuat keputusan yang lebih baik untuk mendatang
berdasarkan contoh-contoh yang disediakan. Tujuan utama adalah untuk mengizinkan
komputer mempelajari secara otomatis tanpa intervensi manusia dan dapat melakukan aksi
penyesuaian yang terkait.

1.2. Kapan Memerlukan Mesin Pembelajaran (Machine Learning)?

Kapankah ML perlu digunakan? Terdapat beberapa masalah yang memerlukan ML, yaitu:
1. Tugas Terlalu Kompleks untuk Diprogram
Dengan perkembangan sekarang ini, masalah yang timbul karena perilaku hewan/
manusia sangat besar sehingga tidak mudah untuk diselesaikan.
2. Tugas Melebihi Kapasitas Manusia
3. Tugas pengenalan bicara, pengenalan gambar, data astronomi, pengenalan cuaca,
informasi medis, data analisis gen, data web, e-commerce, merupakan contoh di mana
manusia tidak bisa melakukan secara langsung.
4. Adaptif
Biasanya, program dibuat dan diinstal maka program kemudian tidak berubah. Lain
halnya program dalam ML di mana program dapat diubah-ubah. Penyimpanan data yang
besar akan dapat dikenali polanya dan kombinasi data memerlukan proses komputer
yang cepat dan terbuka. Selain itu, banyak tugas yang berubah dari waktu ke waktu dari
pengguna data yang satu ke pengguna yang lain karena ada interaksi antarpengguna.
Oleh karena kompleksitas dalam ML maka pembelajaran dibedakan dalam beberapa
tipe, yaitu pembelajaran terbimbing (supervised learning) dan pembelajaran tak terbimbing
(unsupervised learning) di mana keduanya akan dijelaskan pada subbab 1.4.
 Pengenalan Pembelajaran Mesin (Machine Learning) untuk Analisis Data 5

1.3. Kompleksitas dengan Bidang Lain

Karena kompleksitas pemanfaatannya maka ML terkait dengan beberapa bidang, yaitu statistik,
teori informasi, teori permainan, dan optimasi. Sebagai bagian dari komputer sains, ML dapat
dipandang sebagai bagian dari teori kecerdasan buatan (Artificial Intelligence) di mana ML
dapat membuat pengalaman menjadi suatu keahlian atau mendeteksi pola yang bermakna
dalam sensor data yang kompleks dari inteligensi manusia dan hewan.

1.4. Cara Kerja Machine Learning

Machine learning melibatkan proses struktural, di mana setiap tahap membangun versi mesin
yang lebih baik. Untuk penyederhanaan, proses Machine Learning bisa dibagi menjadi 3
bagian yang ditunjukkan pada Gambar 1.1.

Abstraksi Data Generalisasi

Pada bagian ini data Informasi
Data sebagai input
ditampilkan dengan grafik, Setelah mempelajari data,
data.csv
sifat-sifat statistik sederhana diambil kesimpulan

Gambar 1.1 Bagan proses Machine Learning

Langkah-langkah yang digunakan dalam Machine Learning:

1. Mengumpulkan Data
Data mentah bisa berupa Microsoft Excel, Microsoft Access, file teks, dan lain-lain.
Langkah ini membentuk dasar pembelajaran masa depan. Semakin banyak variasi,
kepadatan, dan volume data yang relevan, semakin baik prospek pembelajaran untuk
mesin.
2. Mempersiapkan Data
Setiap proses analitis berkembang dengan kualitas data yang digunakan. Kita perlu
meluangkan waktu untuk menentukan kualitas data dan kemudian mengambil langkah-
langkah untuk memperbaiki masalah seperti kehilangan data dan lainnya.
3. Melatih Sebuah Model
Langkah ini melibatkan pemilihan algoritma dan representasi data yang tepat dalam
bentuk model. Data yang disiapkan dibagi menjadi dua bagian: train dan test. Bagian
6 Machine Learning dengan Python

pertama (training data) digunakan untuk pengembangan model. Bagian kedua (test data),
digunakan sebagai referensi.
4. Mengevaluasi Model
Untuk menguji keakuratan, bagian kedua dari data uji digunakan. Langkah ini menentukan
ketepatan dalam pemilihan algoritma berdasarkan hasil pengujian. Pengujian yang lebih
baik untuk memeriksa ketepatan model adalah dengan melihat kinerjanya pada data
yang tidak digunakan sama sekali selama pembuatan model.
5. Meningkatkan Kinerja
Langkah ini mungkin melibatkan pemilihan model yang berbeda atau memperkenalkan
lebih banyak variabel untuk meningkatkan efisiensi. Itulah sebabnya dibutuhkan banyak
waktu untuk pengumpulan data dan persiapan data.

1.4.1. Pembelajaran Terbimbing (Supervised Learning/SL)

Ada 2 istilah dasar dalam diskusi berikut, yaitu Supervised Learning (SL) dan Unsupervised
Learning (UL) di mana dalam ML sering menggunakan SL. Marilah kita pahami istilah tersebut.
SL adalah algoritma yang mempunyai variabel input (x) dan variabel output/target (Y) dan kita
menggunakan algoritma untuk melakukan pemetaan fungsi dari input ke output, yaitu:

Y = f(x)

Tujuannya adalah mendekati fungsi pemetaan sebaik mungkin sehingga input baru x dapat
memprediksi luaran Y untuk data tersebut. Tentunya mahasiswa pernah melakukan hal ini.
Proses algoritma ini dikatakan SL karena proses algoritma menggunakan himpunan data
latih (data training) yang dianggap sebagai pengajar yang membimbing dalam proses belajar.
Algoritma secara iteratif membuat prediksi pada data latih dan dikoreksi oleh pengajar. Proses
pembelajaran berhenti ketika algoritma pada level yang dapat diterima.

Catatan: perhatikan bahwa istilah pengajar di sini bukan personal selaku seseorang,
tetapi merupakan bagian dari algoritma.

Masalah SL dinyatakan dalam 2 grup, yaitu masalah regresi dan masalah klasifikasi.
Masalah klasifikasi: ketika variabel output sebagai variabel kategori, seperti merah atau biru,
berpenyakit atau tidak berpenyakit.
Masalah regresi: ketika variabel output berupa nilai real, seperti nilai rupiah, berat.
 Pengenalan Pembelajaran Mesin (Machine Learning) untuk Analisis Data 7

Beberapa algoritma SL adalah:

1. Regresi linear untuk masalah regresi.
2. Random forest untuk masalah klasifikasi dan regresi.
3. SVM (Support Vector Machines) untuk masalah klasifikasi.
Dalam literatur yang lain kita dapat menjumpai bahwa ketiganya lebih dinyatakan secara
detail (Web 3). Sebenarnya secara keilmuan, beberapa materi sudah pernah dipelajari
seperti regresi yang dinyatakan dalam regresi linear dan nonlinear (polynomial regression).
Sedangkan nama variabel input dan variabel output dikatakan variabel target. Demikian dalam
regresi digunakan istilah underfitting dan overfitting yang akan dipelajari pada bab selanjutnya.
Daftar SL yang dipelajari secara praktis dalam internet (Web 3) dinyatakan dalam Tabel 1.1, di
mana daftar dalam bahasa Inggris dan dalam bahasa Indonesia.
Tabel 1.1 Daftar SL dalam Bahasa Inggris dan Bahasa Indonesia

Daftar dalam Bahasa Inggris Daftar dalam Bahasa Indonesia

Overfitting and Underfitting Fitting Berlebih dan Fitting yang Kurang
Supervised Learning: Datasets SL dengan Data
K-Nearest Neighbors: Classification and Persekitaran Terdekat Sebesar K: Klasifikasi
Regression dan Regresi
Linear Regression: Least-Squares Regresi Linear: Kuadrat Terkecil
Linear Regression: Ridge, Lasso, and Regresi Linear: Ridge, Lasso, dan Regresi
Polynomial Regression Polinomial
Logistic Regression Regresi Logistik
Linear Classifiers: Support Vector Machines SVM
Multi-Class Classification MCC
Kernelized Support Vector Machines SVM Kernel
Cross-Validation Validasi Bersilang
Decision Trees Pohon Keputusan

Sebenarnya SL untuk tingkat lanjut, masih memuat beberapa bagian sebagaimana pada
Tabel 1.2 yang ditulis dalam bahasa Inggris agar pembaca dapat merujuk dengan kata kunci
yang sama pada literatur ataupun internet.
8 Machine Learning dengan Python

Tabel 1.2 Daftar SL dalam Bahasa Inggris dan Bahasa Indonesia Tingkat Lanjut

Daftar SL Tingkat Lanjut dalam Bahasa Daftar SL Tingkat Lanjut dalam Bahasa
Inggris Indonesia
Naive Bayes Classifiers Klasifikasi Bayes Standard
Random Forests Hutan Acak
Gradient Boosted Decision Trees Pohon Keputusan yang Ditingkatkan
Neural Networks Kemiringannya
Deep Learning (Optional) Pembelajaran Dalam
Data Leakage Kebocoran Data
Dimensionality Reduction Pengurangan Dimensi
Manifold Learning Clustering Berlapis Klastering

1. Model Supervised Learning/Predictive

Model ini digunakan untuk memprediksi hasil masa depan berdasarkan data historis. Model
prediktif biasanya diberi instruksi yang jelas sejak awal, seperti apa yang perlu dipelajari
dan bagaimana itu perlu dipelajari. Sebagai contoh: Supervised Learning digunakan saat
perusahaan pemasaran mencoba untuk mengetahui pelanggan mana yang cenderung
berpindah atau mencari supplier lain. Algoritma ini juga bisa digunakan untuk memprediksi
kemungkinan terjadinya bahaya, seperti gempa bumi, tornado, dan lain-lain (Vasileios et
al., 2022), dengan tujuan untuk mengetahui Total Nilai Asuransi (Kalfin et al., 2022)leading
to the need for continuous innovation in post-disaster economic recovery efforts. Insurance
is one of the offers in providing funding for the economic recovery that occurs. This study
aimed to develop innovations and models for determining natural disaster insurance
premiums with a subsidy and tax system. In addition, the developed model considers the
disaster risk index in the form of the level of risk distribution, the frequency of events, and
economic losses. In this study, the data used were the frequency of events and economic
losses obtained from the Indonesian National Disaster Management Agency. The data
used were 20 database periods from 2000 to 2019. This study used the collective risk
method from the index of natural disaster risk parameters. From the results of the analysis,
it was found that the level of distribution of disaster risk affected the determination of
insurance premiums. The amount of insurance premiums is increasing along with the
increase in the magnitude of the spread of disaster risk. In addition, if taxes and subsidies
are reduced, then for high-risk areas, there will be a decrease in the burden of insurance
 Pengenalan Pembelajaran Mesin (Machine Learning) untuk Analisis Data 9

premiums, and for low-risk areas, there will be an increase in the premium burden that
must be paid. On the basis of the results of the analysis on the insurance model, it was
found that the insurance premiums in each province varied. The results of this study are
expected to be a reference for the government and private companies in implementing
disaster insurance in Indonesia. In addition, the results of this study can be a means of
developing innovations for disaster risk management that occurs.”,”author”:[{“dropping-pa
rticle”:””,”family”:”Kalfin”,”given”:””,”non-dropping-particle”:””,”parse-names”:false,”suffix”:
””},{“dropping-particle”:””,”family”:”Sukono”,”given”:””,”non-dropping-particle”:””,”parse-na
mes”:false,”suffix”:””},{“dropping-particle”:””,”family”:”Supian”,”given”:”Sudradjat”,”non-
dropping-particle”:””,”parse-names”:false,”suffix”:””},{“dropping-particle”:””,”family”:”Mam
at”,”given”:”Mustafa”,”non-dropping-particle”:””,”parse-names”:false,”suffix”:””}],”contain
er-title”:”Computation”,”id”:”ITEM-1”,”issue”:”10”,”issued”:{“date-parts”:[[“2022”]]},”title”:”I
nsurance Premium Determination Model and Innovation for Economic Recovery Due to
Natural Disasters in Indonesia”,”type”:”article-journal”,”volume”:”10”},”uris”:[“http://www.
mendeley.com/documents/?uuid=895d0e19-cceb-46e2-a410-83ca5c2e4dcb”]}],”mendel
ey”:{“formattedCitation”:”(Kalfin et al., 2022. Beberapa contoh algoritma yang digunakan
adalah Nearest Neighbor, Naïve Bayes, Decision Tree, Regression, dan lain-lain.
2. Model Unsupervised Learning
Model ini digunakan untuk melatih di mana tidak ada target yang ditetapkan dan tidak ada
faktor yang penting dari yang lainnya. Sebagai contoh, penggunaan model unsupervised
learning ini, bila seorang penjual pengecer ingin mengetahui kombinasi produk apa yang
cenderung lebih sering dibeli konsumen. Di industri farmasi, digunakan untuk memprediksi
penyakit mana yang mungkin terjadi bersamaan dengan diabetes. Contoh algoritma yang
digunakan di model ini: K-Means Clustering Algorithm.
3. Reinforcement Learning (RL)
Model ini adalah contoh pembelajaran mesin di mana mesin dilatih untuk mengambil
keputusan spesifik berdasarkan kebutuhan bisnis dengan tujuan utama untuk
memaksimalkan efisiensi (kinerja). Ide dari Reinforcement Learning ini adalah mesin/
perangkat lunak melatih dirinya secara terus-menerus berdasarkan lingkungan yang
dipengaruhinya, dan menerapkan pengetahuan yang diperkaya untuk memecahkan
masalah bisnis. Proses belajar yang terus-menerus ini memastikan lebih sedikit
keterlibatan manusia sehingga akan banyak menghemat waktu. Contoh algoritma yang
digunakan dalam RL adalah Markov Decision Process.
10 Machine Learning dengan Python

1.4.2. Contoh-Contoh Penggunaan Machine Learning

Google dan Facebook adalah dua contoh perusahaan yang menggunakan Machine Learning
secara ekstensif untuk mendorong iklan masing-masing ke pengguna yang relevan. Contoh
penggunaan Machine Learning yang lainnya adalah:
1. Layanan Perbankan dan Keuangan
Machine Learning dapat digunakan untuk memprediksi pelanggan yang cenderung
gagal membayar pinjaman atau tagihan kartu kredit. Ini sangat penting karena Machine
Learning akan membantu bank untuk mengidentifikasi nasabah yang dapat diberikan
pinjaman dan kartu kredit (Alonso-Robisco & Carbó, 2022)Trees (CART.
2. Kesehatan
Digunakan untuk mendiagnosis penyakit mematikan (misalnya kanker) berdasarkan
gejala pasien dan menghitungnya dengan data terakhir dari jenis pasien yang sama (An
et al., 2020) (Parhusip et al., 2020).
3. Ritel
Digunakan untuk mengidentifikasi produk yang lebih sering dijual (bergerak cepat) dan
produk yang lamban. Hal ini membantu memutuskan jenis produk yang akan ditampilkan
atau dikeluarkan dari rak. Selain itu, algoritma Machine Learning dapat digunakan
untuk menemukan dua atau lebih produk yang dijual bersama. Hal ini dilakukan untuk
merangsang inisiatif loyalitas pelanggan yang pada gilirannya membantu para peritel
untuk mengembangkan pelanggan setia (Huber & Stuckenschmidt, 2020)for which we
address the problem of forecasting the daily demand for different product categories
at the store level. Such forecasts are an input for production and ordering decisions.
We treat the forecasting problem as a supervised machine learning task and provide
an evaluation of different methods, including artificial neural networks and gradient-
boosted decision trees. In particular, we outline and discuss the possibility of formulating
a classification instead of a regression problem. An empirical comparison with established
approaches reveals the superiority of machine learning methods, while classification-
based approaches outperform regression-based approaches. We also found that machine
learning methods not only provide more accurate forecasts but are also more suitable for
applications in a large-scale demand forecasting scenario that often occurs in the retail
industry.”,”author”:[{“dropping-particle”:””,”family”:”Huber”,”given”:”Jakob”,”non-dropping-
particle”:””,”parse-names”:false,”suffix”:””},{“dropping-particle”:””,”family”:”Stuckenschm
idt”,”given”:”Heiner”,”non-dropping-particle”:””,”parse-names”:false,”suffix”:””}],”contain
 Pengenalan Pembelajaran Mesin (Machine Learning) untuk Analisis Data 11

er-title”:”International Journal of Forecasting”,”id”:”ITEM-1”,”issue”:”4”,”issued”:{“date-

parts”:[[“2020”]]},”page”:”1420-1438”,”title”:”Daily retail demand forecasting using machine
learning with emphasis on calendric special days”,”type”:”article-journal”,”volume”:”36”},”
uris”:[“http://www.mendeley.com/documents/?uuid=1bdef513-6dc4-4411-bc08-e47a6907
e139”]}],”mendeley”:{“formattedCitation”:”(Huber & Stuckenschmidt, 2020.

1.4.3. Pembelajaran Mesin tak Terbimbing (Unsupervised Machine Learning/

UML)
Pada UML kita hanya punya data input, tetapi tidak punya output. Tujuan UML adalah suatu
model berdasarkan struktur atau distribusi data untuk mempelajari lebih lanjut tentang data
tersebut. Metode ini disebut UML karena tidak ada jawaban yang benar dan tidak ada pengajar
yang mengoreksi. Algoritma menyerahkan pada alat yang digunakan dalam menemukan
sesuatu dan menghasilkan struktur yang menarik dari data. UML dapat digolongkan dalam
masalah clustering dan asosiasi.
1. Masalah clustering: Masalah clustering merupakan upaya menemukan pengelompokan
dalam data sehingga diperoleh kelompok yang sifatnya dikehendaki.
2. Aturan asosiasi: masalah aturan asosiasi adalah ketika kita menghendaki menemukan
aturan yang menjelaskan porsi besar data, misal suatu kelompok orang yang menghendaki
membeli barang X, tetapi juga membeli barang Y.
Algoritma yang terkait dengan UML di antaranya:
1. k-means clustering.
2. algoritma apriori untuk aturan asosiasi.

1.4.4. Semi Mesin Pembelajaran Terbimbing (Semi-Supervised Machine

Learning/SSML)
Masalah dengan input data yang sangat besar dan hanya beberapa data berlabel tergolong
pada masalah SSML, misalkan suatu foto hanya sebagian yang diberi label, sedangkan
sebagian besar tidak. Masalah nyata sering kali tergolong pada masalah seperti ini. Hal ini
muncul umumnya karena waktu yang besar untuk melabeli data dan memerlukan akses pada
domain data, sedangkan data yang tidak berlabel, murah dan mudah untuk di koleksi dan
disimpan. Kita dapat menggunakan USL untuk menemukan struktur data input kemudian
kita menggunakan teknik SL untuk menduga data tak-berlabel. Data tersebut kemudian kita
12 Machine Learning dengan Python

gunakan dalam algoritma SL sebagai data training dan menggunakan model untuk membuat
prediksi pada data baru yang tidak terlihat.

Kesimpulan Sementara
Sebagai kesimpulan untuk diskusi di atas, kita dapat mengatakan:
SL : Semua data berlabel dan algoritma belajar untuk memprediksi luaran dari data input.
UL : semua data tidak berlabel dan algoritma mempelajari struktur data input.
SSL : beberapa data berlabel, tetapi sebagian besar tidak berlabel dan campuran metode SL
dan USL digunakan.
Apakah selama ini para peneliti belum melakukan pengembangan hal ini sebelum istilah atau
ilmu ML dikembangkan? Jika dicermati, ML muncul sehubungan kompleksitas data yang timbul
dan perubahan yang berlaku secara simultan dengan perubahan data serta sangat cepat. ML
memberikan generalisasi terhadap beberapa metode klasik yang sudah ada, seperti regresi
dan clustering, serta memberikan pengembangan terhadap metode klasik tersebut dengan
bahasa pemrograman yang up to date saat ini.

1.5. Langkah-Langkah Pengolahan Data dalam Machine Learning

Berikut ini diberikan langkah-langkah praktis dalam pengolahan data dengan bahasa mesin.
1. Pembacaan Data
Tahap pembacaan data, misalkan menampilkan data, menampilkan dimensi data,
menghitung tiap kelas, menampilkan data per faktor/variabel.
2. Membersihkan Data
Membersihkan data diperlukan dalam pengolahan data machine learning, di mana
data dapat dipertanggungjawabkan untuk kemudian dapat diolah. Beberapa proses
membersihkan data dikarenakan:
a. Observasi ganda ataupun tidak relevan.
b. Salah dalam pelabelan, kategori yang sama terjadi berulang.
c. Data hilang atau ada data yang kosong (null data).
d. Terdapat outlier yang tidak diharapkan.
Pada kegiatan ini dapat dianggap bahwa tentang bagian a atau b sudah baik (observasi
relevan dan tidak salah dalam pelabelan). Untuk itu kita mengobservasi ada tidaknya data
yang hilang.
 Pengenalan Pembelajaran Mesin (Machine Learning) untuk Analisis Data 13

3. Mencermati Data Outlier

Data-data di atas dibaca dan dikatakan invalid. Untuk mengatasi data invalid maka
diperlukan langkah-langkah sebagai berikut:
a. Abaikan/hapus data invalid: Hal ini jelas tidak mungkin pada hampir semua kasus
karena hal ini berarti kehilangan informasi yang berharga.
b. Membuat rata-rata: pada data yang invalid diisi data rata-rata. Hal ini kemungkinan
dapat berlaku pada beberapa data, tetapi dengan menggantikan nilai rata-rata dapat
memberikan informasi yang salah pada model.
c. Menghindari menggunakan faktor-faktor tersebut: hal ini mungkin dapat dilakukan
jika data banyak memuat informasi yang invalid. Misalkan hal ini berlaku pada
ketebalan kulit, tetapi kemudian kita juga sulit melakukan prediksi.
4. Mencermati Data yang Hilang
Terkadang data tidak lengkap. Beberapa bagian data tidak dapat diperoleh karena
keadaan yang tidak mendukung. Untuk itu, data perlu dicermati karena dapat terjadi hasil
observasi data, atau hasil pengukuran tidak memberikan struktur yang sama. Untuk itu,
program perlu dibuat agar memberikan informasi data yang sama strukturnya untuk dapat
diolah dengan benar.

1.5.1. Proses Teknis Lebih Lanjut

Proses teknis lebih lanjut adalah proses mentransformasi data menjadi lebih baik dalam
mempresentasikan masalah yang akan diselesaikan dalam model sehingga memperbaiki
model dan akurasi model. Proses ini memberikan lebih faktor-faktor sebagai input terhadap
faktor-faktor yang sudah ada dan menggabungkan beberapa faktor agar menghasilkan faktor-
faktor yang secara intuitif (karena belum dibuktikan) pada model. Selain itu, penambahan
faktor diharapkan tidak memberikan overfitting. Karena data sudah disediakan dan dengan
mencermati data seperti di atas, kita tidak dapat membuat atau menghilangkan data pada
langkah ini.
Umumnya, faktor teknis ditunjukkan sebelum pemilihan model. Akan tetapi, pada tulisan
ini, kita melakukan pendekatan yang berbeda. Fitur teknis (ditulis dalam bahasa Inggris adalah
Feature Engineering). Pendekatan tersebut, yaitu mencermati semua faktor dalam data dan
mendiskusikan seberapa penting faktor-faktor tersebut dalam model.
14 Machine Learning dengan Python

1.5.2. Pemilihan Model

Pemilihan model atau algoritma pemilihan merupakan algoritma yang paling menarik dan
menjadi jantung utama dalam machine learning. Hal ini merupakan fase di mana kita memilih
model dan menampilkan data secara terbaik. Langkah awal yang dilakukan adalah melakukan
Uji Akurasi dari model-model klasifikasi berdasarkan parameter yang sudah ditetapkan untuk
tiap model dikatakan baik. Algoritma utama untuk hal ini adalah K-Nearest Neighbors, Support
Vector Classifier, Logistic Regression, Gaussian Naive Bayes, Random Forest and Gradient
Boost sebagai pengklasifikasi model terbaik.

1.5.3. Mengevaluasi Model

Pada langkah praktis yang umum maka kita perlu menghindari data latih dan data uji pada data
yang sama. Model mempunyai tujuan untuk memprediksi data yang di luar sampel data dan
model dapat kompleks sehingga dapat terjadi overfitting. Untuk menghindari hal-hal demikian,
terdapat 2 langkah awal:
1. Memisahkan data menjadi data latih dan data uji yang disebut train/test method.
2. Melakukan validasi silang K-kali yang disebut K-Fold Cross Validation.
Selanjutnya, algoritma akan memberikan nilai akurasi masing-masing model dari langkah
ke-2 di atas untuk mengevaluasi akurasi dari model dalam metode train/test.
Mengimpor fungsi-fungsi yang diperlukan dengan Python adalah:

from sklearn.model_selection import train_test_split

from sklearn.model_selection import cross_val_score
from sklearn.metrics import accuracy_score
from sklearn.model_selection import KFold # ini
ditambahkan karena tidak ada, tetapi perlu
Selanjutnya, kita memilih nilai akurasi tertinggi yang menunjukkan model terbaik.

1.6. Penggunaan ML dengan Python

Pada langkah ini, kita akan membuat data menjadi 2, yaitu data latih (training set) dan data uji
(testing set) di mana data uji untuk menguji model dan mengevaluasi akurasi.
 Pengenalan Pembelajaran Mesin (Machine Learning) untuk Analisis Data 15

1.6.1. Pemisahan dengan Scikit Learn

Jadi kita akan memisahkan faktor-faktor dan respons dalam data latih dan data uji. Kita
melakukan proses ini di mana setiap kelas respons (misal yang berlabel diabetes) diwakili
dengan porsi yang sama pada tiap sampel data. Selanjutnya, kita akan memasangkan data
terhadap setiap model dan menghitung akurasi setiap model dengan nilai akurasi.

1.6.2. Validasi Silang (K-cross Validation)

Metode ini melakukan pemisahan data menjadi partisi sebanyak K-partisi yang sama dan
menggunakan 1 lapisan (fold) sebagai data uji dan kemudian menggabungkan partisi yang
lain sebagai data latih. Kemudian model diuji akurasinya. Proses ini akan dilakukan K-kali
dengan menggunakan partisi yang berbeda sebagai data uji setiap waktu. Akurasi rata-rata
uji dalam proses merupakan akurasi hasil uji model. Dengan ini, estimasi untuk data di luar
data sampel akan lebih akurat, serta dikatakan lebih efisien dalam menggunakan data (setiap
observasi digunakan untuk data latih dan data uji). Akan tetapi, kendala yang dihadapi bahwa
metode ini lebih lambat dibandingkan metode pemisahan di atas (Train /Test Split). Proses ini
digambarkan pada Gambar 1.2.

Data

Data latih (training) (Ta) Data uji (test) (Te)

(Te)

(Te)

Gambar 1.2 Partisi data dengan K=3 kali partisi

16 Machine Learning dengan Python

Perhatikan bahwa dalam penulisan di atas kita hanya belajar dalam membaca data,
membersihkan data, dan mengevaluasi data terhadap beberapa model sehingga dapat dipilih
secara otomatis atas model-model yang dipilih. Terdapat banyak model yang sudah diujicobakan
terhadap data tersebut di mana kita belum menelusuri masing-masing model secara lebih
detail, yaitu K-Nearest Neighbors, Support Vector Classifier, Logistic Regression,
Gaussian Naive Bayes, Random Forest and Gradient Boost, akan tetapi telah dipelajari
melalui video. Pemilihan data terhadap model Logistic Regression menunjukkan bahwa model
yang lain dapat underfitting atau overfitting. Selain memahami masing-masing model lebih
detail maka hasil pemodelan terhadap data dengan LR perlu diperhatikan lebih lanjut.

1.6.3. Proses Pemodelan Data yang Sudah Bersih

Sebagaimana disebutkan bahwa data telah dibersihkan kita dapat langsung memproses
pengolahan data pada program yang baru dengan hasil identifikasi digunakan untuk langsung
kembali memanggil data.

1.7. Overfitting dan Underfitting

Secara sederhana overfitting (OF) dan underfitting (UF) merupakan proses memodelkan
data untuk menyesuaikan dengan kurva tertentu yang diasumsikan dapat menggambarkan
data. Kata over menyatakan sifat yang kelebihan di mana kurva yang digunakan mempunyai
derajat ketelitian yang terlalu banyak. Jika pola data linear, tidaklah tepat mengasumsikan data
berpola kuadratik atau polynomial derajat lebih tinggi. Kasus demikian dikatakan overfitting.
Demikian pula sebaliknya, jika data berpola tidak linear (sinusoidal) memuat noise, tidak
mungkin menggunakan model linear. Kasus demikian yang disebut underfitting.
Overfitting dan underfitting dapat terjadi juga dalam kegiatan klasifikasi seperti clustering
di mana salah satu metode menggunakan kurva sebagai batas pembeda antarklaster.
Demikian pula setelah melakukan fitting, tentu diperlukan evaluasi terhadap model yang
diperoleh di mana pada machine learning digunakan metode cross validation yang secara
mudah diterjemahkan sebagai validasi silang. Dari istilah ini, kita diinspirasi bahwa model yang
ada kemudian divalidasi dengan mencocokkan terhadap data. Program yang memberikan
contoh overfitting (OF) dan underfitting (UF) diberikan pada internet (Web 4) dan ditampilkan
pada contoh berikut.
 Pengenalan Pembelajaran Mesin (Machine Learning) untuk Analisis Data 17

Contoh 1.1
Misalkan kita membangkitkan data sebagai fungsi + di mana dan sebagai bilangan random
agar data yang dibangkitkan dari fungsi memuat derau (noise). Kemudian diasumsikan bahwa
data (pasangan (x,y)) tersebut sebagai fungsi polinomial derajat 1, 4, dan 15. Tentu saja
polinomial derajat 1 tidak cukup. Secara langsung, telah diketahui data tidak berpola linear
sehingga pendekatan sebagai fungsi polinomial derajat 1 masih kurang tepat. Pendekatan ini
dikatakan underfitting. Sedangkan polinomial derajat 4 dan 15 merupakan kandidat yang dapat
dianggap tepat menyatakan fungsi cosinus di atas. Akan tetapi, jika polinomial derajat 4 sudah
terlihat cukup baik secara visual menyatakan fungsi cosinus di atas maka polinomial derajat
15 mendekati data tersebut terlalu berlebihan sehingga disebut overfitting. Perhatikan bahwa
menyatakan fungsi sebagai polinomial derajat 15 berarti terdapat 16 parameter polinomial
yang harus ditentukan. Secara komputasi, polinomial derajat 15 lebih kompleks dibandingkan
menentukan polinomial derajat 4. Program di bawah menjelaskan hal ini dengan luaran
Gambar 1.3.

Contoh 1.2a
print(__doc__)
import numpy as np
import matplotlib.pyplot as plt
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import cross_val_score
def true_fun(X):
return np.cos(1.5 * np.pi * X)
np.random.seed(0)

n_samples = 30
degrees = [1, 4, 15]

X = np.sort(np.random.rand(n_samples))
y = true_fun(X) + np.random.randn(n_samples) * 0.1
18 Machine Learning dengan Python

plt.figure(figsize=(14, 5))
for i in range(len(degrees)):
ax = plt.subplot(1, len(degrees), i + 1)
plt.setp(ax, xticks=(), yticks=())

polynomial_features =
PolynomialFeatures(degree=degrees[i],

include_bias=False)
linear_regression = LinearRegression()
pipeline = Pipeline([(“polynomial_features”,
polynomial_features),
“linear_regression”, linear_regression)])
pipeline.fit(X[:, np.newaxis], y)

# Mengevaluasi model dengan cross validasi

scores = cross_val_score(pipeline, X[:,
np.newaxis], y,
scoring=”neg_mean_squared_error”, cv=10)

X_test = np.linspace(0, 1, 100)

plt.plot(X_test, pipeline.predict(X_test[:,
np.newaxis]), label=”Model”)
plt.plot(X_test, true_fun(X_test), label=”Fungsi
yang benar”)
plt.scatter(X, y, edgecolor=’b’, s=20, label=”Data
sampel”)
plt.xlabel(“x”)
plt.ylabel(“y”)
plt.xlim((0, 1))
plt.ylim((-2, 2))
 Pengenalan Pembelajaran Mesin (Machine Learning) untuk Analisis Data 19

plt.legend(loc=”best”)
plt.title(“Derajat polinomial {}\nMSE = {:.2e}(+/-
{:.2e})”.format(
degrees[i], -scores.mean(), scores.std()))
plt.show()

Hasil luaran ditunjukkan berikut ini.

Gambar 1.3 Ilustrasi underfitting (kiri), overfitting (kanan), dan fitting yang tepat (tengah)

Pada Gambar 1.3 ditunjukkan bagaimana kedua istilah, yaitu underfitting dan overfitting
diilustrasikan. Pola data dapat diilustrasikan secara masuk akal dengan polinomial derajat 4.
Sebelum kita melakukan penjelasan tahap-tahap pengolahan data dalam ML maka berikut ini
perlu dijelaskan bagaimana proses pengolahan data dengan ML dilakukan.

Contoh 1.2b
Pada bagian ini akan ditunjukkan tahapan yang dijelaskan di atas untuk data observasi yang
diperoleh di internet, yaitu untuk observasi terhadap penyakit diabetes.
1. Latar Belakang
Diabetes dikenal sebagai penyebab kematian dini dan disabilitas. Oleh karena itu,
diabetes merupakan salah satu dari 4 penyakit yang ditargetkan untuk dicegah dan
dikontrol dalam dunia sejak 2013 menurut WHO. Pada tahun 2012, tercatat bahwa 1.5
kematian manusia di bumi dikarenakan diabetes di mana sebagai tingkat ke-8 penyebab
kematian dan sebagai penyebab kematian pada wanita tingkat ke-5 di dunia.
20 Machine Learning dengan Python

Diabetes merupakan salah satu penyakit yang dianggap kronis ketika pankreas tidak
berfungsi dalam menghasilkan insulin (hormon yang mengatur gula darah) dan/atau
ketika tubuh tidak efektif memproduksi insulin. Ada 2 tipe diabetes yang juga dikenal.
Tipe 1 diabetes dikenal sebagai kebergantungan insulin yang dicirikan oleh penurunan
produksi insulin sehingga penderita harus secara teratur mengonsumsi insulin untuk
mengatur glukosa dalam darah. Tipe ini tidak diketahui penyebabnya dan masih belum
dapat dicegah. Untuk penderita diabetes tipe 2 disebut juga penderita yang bergantung
pada non-insulin yang sebagian besar terjadi pada manusia dewasa di mana gejalanya
seperti pada tipe 1 hanya saja tidak terdiagnosis pada beberapa tahun hingga terjadi
komplikasi. Jenis lain adalah bentuk transisi antara tipe 1 dan tipe 2 yang disebut Impaired
Glucose Tolerance (IGT) dan Impaired Fasting Glycaemia (IFG) di mana orang dalam
kondisi ini sering kali dalam kondisi gula darah tidak normal sehingga terjadi serangan
jantung dan stroke. Demikian pula Gestational Diabetes (GDM) merupakan salah satu
jenis penyakit diabetes dengan kondisi temporer yang mana terjadi pada kehamilan.
Hal ini terjadi ketika glukosa dalam darah bernilai di atas normal, tetapi masih kondisi di
bawah terdiagnosis sebagai penderita diabetes. Risiko meningkat selama kehamilan dan
dapat diturunkan kepada calon bayi.
Dengan memperhatikan tingginya pengaruh penyakit diabetes terhadap kematian
manusia di dunia, penelitian terhadap pencegahan dan penyembuhan terhadap penyakit
ini telah banyak dilakukan oleh para peneliti. Salah satu data penelitian telah dinyatakan
di internet terhadap 768 orang wanita dengan 9 faktor dari National Institute of Diabetes
and Digestive and Kidney Diseases. Data dicatat baik terhadap pasien yang terdiagnosis
diabetes ataupun tidak. Beberapa faktor tersebut akan ditinjau lebih detail dalam tulisan
ini. Faktor yang diukur tentunya faktor-faktor yang dianggap berpengaruh secara signifikan
terindikasi tidaknya seseorang sebagai penderita diabetes. Oleh karena itu, keadaan
hamil atau tidak dicatat sebagai salah satu faktor.
Adapun faktor-faktor selengkapnya adalah:
Kehamilan : Banyaknya kehamilan yang pernah dialami.
Glukosa : Konsentrasi glukosa dalam 2 jam tes toleransi glukosa dalam uji gula
darah.
Tekanan darah : tekanan darah dalam keadaan diastolik (mm/Hg).
Tebal kulit : ketebalan lipatan dalam otot di bawah kulit (mm).
Insulin : serapan serum insulin dalam 2 jam (mu U/ml satuan).
 Pengenalan Pembelajaran Mesin (Machine Learning) untuk Analisis Data 21

BMI (Body Mass Index): berat dalam kg/tinggi dalam meter kuadrat.
Fungsi pedigree : merupakan sejarah diabetes mellitus yang relatif terkait dengan faktor
genetik.
Umur : umur pasien (dalam tahun).
Luaran : variabel kelas (0 atau 1), 1: untuk pasien terdiagnosis diabetes, 0: untuk
pasien terdiagnosis tidak diabetes.
BMI pada umumnya pada 18.5-24.9 dikatakan normal, sedangkan dalam nilai 25-29.9
dikatakan berat berlebih, dan jika > 30 maka dikategorikan obesitas.
2. Langkah-Langkah Pengolahan Data
a. Pembacaan Data
Penamaan variabel untuk 9 faktor di atas sebagai berikut: Kehamilan, Glukosa,
Tekanan Darah, Tebal Kulit, Insulin, BMI, Fungsi Pedigree, Umur, Luaran. Contoh
daftar data ditunjukkan pada Tabel 1.3.
Tabel 1.3 Contoh data yang Dianalisis Hasil Observasi oleh National Institute of Diabetes
and Digestive and Kidney Diseases terhadap 768 wanita

Tekanan Tebal Fungsi

Kehamilan Glukosa Insulin BMI Umur Luaran
Darah Kulit Pedigree
6 148 72 35 0 33.6 0.627 50 1
1 85 66 29 0 26.6 0.351 31 0
8 183 64 0 0 23.3 0.672 32 1
1 89 66 23 94 28.1 0.167 21 0
0 137 40 35 168 43.1 2.288 33 1
5 116 74 0 0 25.6 0.201 30 0
3 78 50 32 88 31 0.248 26 1
10 115 0 0 0 35.3 0.134 29 0

Langkah-langkah pemrograman sebagai berikut:

Langkah 1. Program Python Memanggil Fungsi
https://towardsdatascience.com/machine-learning-workflow-on-diabetes-data-part-01-
573864fcc6b8
22 Machine Learning dengan Python

%matplotlib inline
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
diabetes= pd.read_csv(.....diabetesIndo.csv’)
diabetes.columns

Hasil program:
Index([u’Kehamilan’, u’Glukosa’, u’Tekanandarah’,
u’Tebalkulit’, u’Insulin’,
u’BMI’, u’FungsiPedigree’, u’Umur’, u’Luaran’],
dtype=’object’)

Langkah 2. Menampilkan Data

diabetes.head()

Hasil program:

Tekanan Tebal Fungsi

Kehamilan Glukosa Insulin BMI Umur Luaran
Darah Kulit Pedigree
0 6 148 72 35 0 33.6 0.627 50 1
1 1 85 66 29 0 26.6 0.351 31 0
2 8 183 64 0 0 23.3 0.672 32 1
3 1 89 66 23 94 28.1 0.167 21 0
4 0 137 40 35 168 43.1 2.288 33 1
 Pengenalan Pembelajaran Mesin (Machine Learning) untuk Analisis Data 23

Langkah 3. Memperhatikan Dimensi Data

print(“Dimensi data diabetes : {}”.format(diabetes.
shape))

Hasil program:
Dimensi data diabetes: (768, 9)

Langkah 4. Untuk menghitung tiap kelas

#Untuk mengidentifikasi berapa diabetes (1 diabetes dan
0 jika tidak)
diabetes.groupby(‘Luaran’).size()

Hasil program:
Luaran
0 500
1 268
dtype: int64

Langkah 5. Menampilkan data per faktor dengan berdasarkan klasifikasi Luaran

diabetes.groupby(‘Luaran’).hist(figsize=(9, 9))

Hasil program:
Luaran
0 [[AxesSubplot(0.125,0.670278;0.215278x0.209722...
1 [[AxesSubplot(0.125,0.670278;0.215278x0.209722...
dtype: object
24 Machine Learning dengan Python

Gambar 1.4 Distribusi data pasien yang berlabel 0 (tidak diabetes)

 Pengenalan Pembelajaran Mesin (Machine Learning) untuk Analisis Data 25

Gambar 1.5 Distribusi data pasien yang berlabel 1 (diabetes)

Penjelasan:
Perhatikan bahwa Gambar 1.4 dan 1.5 menunjukkan distribusi data untuk masing-masing
faktor.
26 Machine Learning dengan Python

b. Membersihkan Data
Beberapa proses membersihkan data dikarenakan:
1) Observasi ganda ataupun tidak relevan.
2) Salah dalam pelabelan, kategori yang sama terjadi berulang.
3) Data hilang atau ada data yang kosong (null data).
4) Terdapat outlier yang tidak diharapkan.
Pada kegiatan ini dapat dianggap bahwa tentang bagian a atau b sudah baik
(observasi relevan dan tidak salah dalam pelabelan). Untuk itu, kita mengobservasi
ada tidaknya data yang hilang.

c. Mencermati Data yang Hilang

Langkah 6. #Untuk mengenali ada tidaknya missing data, ternyata hasil menunjukkan
tidak adanya data yang kosong.
diabetes.isnull().sum()
diabetes.isna().sum()

Hasil program:
Kehamilan 0
Glukosa 0
Tekanandarah 0
Tebalkulit 0
Insulin 0
BMI 0
FungsiPedigree 0
Umur 0
Luaran 0
dtype: int64

Penjelasan: tidak ada data yang missing. Akan tetapi, ketika data ditelusuri, terdapat
kesalahan karena seseorang tidak mungkin mempunyai tekanan darah 0. Dengan
menelusuri data maka terdapat 35 orang yang terhitung bertekanan darah 0.
 Pengenalan Pembelajaran Mesin (Machine Learning) untuk Analisis Data 27

d. Mencermati Data Outlier

Dengan memperhatikan histogram pada Gambar 1.4 dan Gambar 1.5 terdapat
beberapa data bertipe outlier (tidak mengumpul pada sebagian besar data). Data
yang memuat outlier adalah data pada tekanandarah, level glukosa, ketebalan
kulit, BMI dan insulin. Setelah teramati, kemudian dapat ditentukan bagaimana data
diolah selanjutnya.

Langkah 7. Perintah untuk menelusuri banyaknya data bertekanan darah 0

print(“Total : “, diabetes[diabetes.Tekanandarah ==
0].shape[0])

Hasil program:
(‘Total : ‘, 35)
Luaran
0 19
1 16
Name: Umur, dtype: int64

Langkah 8. Mencermati level glukosa plasma: sekalipun sudah puasa, level glukosa
tidak mungkin 0 sehingga jika level glukosa bernilai 0 berarti terdapat kesalahan data.
Dengan mengobservasi data maka diperoleh 5 orang mempunyai nilai glukosa 0.
print(“Total : “, diabetes[diabetes.Glukosa ==
0].shape[0])

Hasil program:
(‘Total : ‘, 5)

Langkah 9. Dari 5 orang di atas akan dicermati berapa orang yang teridentifikasi diabetes
(berlabel 1) dan yang tidak diabetes (berlabel 0)
print(diabetes[diabetes.Glukosa ==0].groupby(‘Luaran’)
[‘Umur’].count())
28 Machine Learning dengan Python

Hasil program:
Luaran
0 3
1 2
Name: Umur, dtype: int64

Langkah 10. Demikian pula, kita akan mencermati berdasarkan Tebal kulit di mana orang
normal ketebalan bawah kulit tidak boleh lebih kecil dari 10 mm. Dari program diperoleh
bahwa yang bernilai 0 sebanyak 227.
Program
print(“Total : “, diabetes[diabetes.Tebalkulit ==
0].shape[0])
print(diabetes[diabetes.Tebalkulit ==
0].groupby(‘Luaran’)[‘Umur’].count())

Hasil program:
(‘Total : ‘, 227)
Luaran
0 139
1 88
Name: Umur, dtype: int64

Penjelasan: Jadi dari 227 orang teridentifikasi tebal kulit 0 maka untuk orang yang tidak
teridentifikasi diabetes (berlabel 0) ada 139 dan yang berlabel 1 ada 88 orang.
Langkah 11. Demikian pula untuk BMI, tidak boleh teridentifikasi BMI bernilai 0, untuk itu
dihitung berapa orang BMI bernilai 0 dan berdasarkan kelasnya maka dapat teridentifikasi
dengan 9 orang yang tidak diabetes dengan BMI bernilai 0 dan 2 orang BMI dengan nilai
0 untuk 2 orang diabetes.
#BMI tidak boleh lebih kecil dari nol
print(“Total : “, diabetes[diabetes.BMI ==
0].shape[0])
print(diabetes[diabetes.BMI == 0].groupby(‘Luaran’)
[‘Umur’].count())
 Pengenalan Pembelajaran Mesin (Machine Learning) untuk Analisis Data 29

Hasil program:
Outcome
0 9
1 2
Name: Age, dtype: int64

Langkah 12. Secara sama, kita dapat mengidentifikasi kadar insulin pada tiap kelas.
Pada situasi sangat jarang, seseorang dapat mempunyai insulin 0, tetapi berdasarkan
data observasi maka terdapat 374 orang dinyatakan berkadar insulin 0.
Program:
print(“Total : “, diabetes[diabetes.Insulin ==
0].shape[0])
print(diabetes[diabetes.Insulin ==
0].groupby(‘Luaran’)[‘Umur’].count())

Hasil program:
(‘Total : ‘, 374)
Luaran
0 236
1 138
Name: Umur, dtype: int64

Langkah 13. Untuk mengedit data

Data-data di atas dibaca dan dikatakan invalid. Untuk mengatasi data invalid, kita akan
melakukan pembersihan data dengan menghapus faktor Tekanan darah, BMI, dan
Glukosa yang bernilai 0 pada program berikut.
diabetes_mod = diabetes[(diabetes.Tekanandarah != 0) &
(diabetes.BMI != 0) & (diabetes.Glukosa != 0)]
print(diabetes_mod.shape)

Hasil program:
(724, 9)
Penjelasan: Jadi semula data observasi memuat 768 orang maka data dibuang menjadi
724 di mana data yang dibuang memuat data yang invalid.
30 Machine Learning dengan Python

e. Proses Teknis Lebih Lanjut

Karena data sudah disediakan dan dengan mencermati data seperti di atas, kita
tidak dapat membuat atau menghilangkan data pada langkah ini. Pada data yang
sudah ada maka kita mempunyai 9 faktor di atas. Dengan observasi kasar tanpa
program, ketebalan kulit sebenarnya bukan indikator dalam diabetes, akan tetapi,
kita tidak dapat menghindari fakta bahwa data tersebut sebenarnya tidak berguna
pada langkah ini. Oleh karena itu, kita akan menggunakan semua faktor yang sudah
ada dan kita akan memisahkan data di mana data terdiri dari variabel X dan Y.
Program:
namafaktor = [‘Kehamilan’, ‘Glukosa’, ‘Tekanandarah’,
‘Tebalkulit’, ‘Insulin’, ‘BMI’, ‘FungsiPedigree’,
‘Umur’]
X = diabetes_mod[namafaktor]
y = diabetes_mod.Luaran

Umumnya, faktor teknis ditunjukkan sebelum pemilihan model. Akan tetapi, pada makalah
ini kita melakukan pendekatan yang berbeda. Faktor teknis (ditulis dalam bahasa Inggris
adalah Feature Engineering). Pendekatan tersebut yaitu mencermati semua faktor dalam
data dan mendiskusikan seberapa penting faktor-faktor tersebut dalam model.

f. Pemilihan Model
Pemilihan model atau algoritma pemilihan merupakan algoritma yang paling menarik
dan menjadi jantung utama dalam machine learning. Hal ini merupakan fase di
mana kita memilih model dan menampilkan data secara terbaik. Langkah awal yang
dilakukan adalah melakukan Uji Akurasi dari model-model klasifikasi berdasarkan
parameter yang sudah ditetapkan untuk tiap model dikatakan baik. Algoritma
utama untuk hal ini adalah K-Nearest Neighbors, Support Vector Classifier, Logistic
Regression, Gaussian Naive Bayes, Random Forest and Gradient Boost sebagai
pengklasifikasi model terbaik.

Langkah 14. Mengimpor algoritma pengklasifikasi model

Program:
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
 Pengenalan Pembelajaran Mesin (Machine Learning) untuk Analisis Data 31

from sklearn.linear_model import LogisticRegression

from sklearn.tree import DecisionTreeClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import GradientBoostingClassifier

Langkah 15. Kita akan menginisialisasi model-model klasifikasi dengan parameter yang
sudah baku (default) dan menambahkan parameter tersebut dalam daftar model.
Program:
models = []
models.append((‘KNN’, KNeighborsClassifier()))
models.append((‘SVC’, SVC()))
models.append((‘LR’, LogisticRegression()))
models.append((‘DT’, DecisionTreeClassifier()))
models.append((‘GNB’, GaussianNB()))
models.append((‘RF’, RandomForestClassifier()))
models.append((‘GB’, GradientBoostingClassifier()))

g. Mengevaluasi Model
Model mempunyai tujuan untuk memprediksi data yang di luar sampel data dan
model dapat kompleks sehingga dapat terjadi overfitting. Untuk menghindari hal-hal
demikian, terdapat 2 langkah awal:
1) Memisahkan data menjadi data latih dan data uji yang disebut train/test method.
2) Melakukan validasi silang K-kali yang disebut K-Fold Cross Validation.
Selanjutnya, algoritma akan memberikan nilai cross_val_score dari langkah ke-2 di
atas untuk mengevaluasi akurasi dari model dalam metode train/test.

Langkah 16. Mengimpor fungsi-fungsi yang diperlukan

Program:
from sklearn.model_selection import train_test_split
from sklearn.model_selection import cross_val_score
from sklearn.metrics import accuracy_score
32 Machine Learning dengan Python

from sklearn.model_selection import KFold

# ini ditambahkan karena tidak ada, tetapi perlu
Selanjutnya, kita akan menampilkan metode di atas untuk menentukan model standar
yang terbaik.

h. Pemisahan Data Latih dan Data Uji

Pada langkah ini, kita akan membuat data menjadi 2, yaitu data latih (training set)
dan data uji (testing set) di mana data uji untuk menguji model dan mengevaluasi
akurasi.

Langkah 17. Pemisahan dengan Scikit Learn

Jadi kita akan memisahkan faktor-faktor dan respons dalam data latih dan data uji. Kita
melakukan proses ini di mana setiap kelas respons (misal yang berlabel diabetes) diwakili
dengan porsi yang sama pada tiap sampel data.
Program:
X_train, X_test, y_train, y_test = train_test_split(X,
y, stratify = diabetes_mod.Luaran, random_state=0)

Selanjutnya, kita akan memasangkan data terhadap setiap model dan menghitung akurasi
setiap model dengan nilai akurasi.
Program:
names = []
scores = []
for name, model in models:
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
scores.append(accuracy_score(y_test, y_pred))
names.append(name)
tr_split = pd.DataFrame({‘Nama’: names, ‘Nilai’:
scores})
print(tr_split)
 Pengenalan Pembelajaran Mesin (Machine Learning) untuk Analisis Data 33

Hasil program:
Nama Nilai
0 KNN 0.729282
1 SVC 0.657459
2 LR 0.767956
3 DT 0.701657
4 GNB 0.734807
5 RF 0.767956
6 GB 0.773481

Penjelasan: setiap model mempunyai nilai akurasi. Jika semua angka di belakang koma
signifikan maka model LR (Logistic Regression) dianggap paling akurat.

i. Validasi Silang (K-cross validation)

Langkah 18.
Proses ini akan dilakukan K-kali dengan menggunakan partisi yang berbeda sebagai data
uji setiap waktu. Akurasi rata-rata uji dalam proses merupakan akurasi hasil uji model.
Dengan ini, estimasi untuk data di luar data sampel akan lebih akurat serta dikatakan
lebih efisien dalam menggunakan data (setiap observasi digunakan untuk data latih dan
data uji). Akan tetapi, kendala yang dihadapi bahwa metode ini lebih lambat dibandingkan
metode pemisahan di atas (Train/Test Split).
Program:
names = []
scores = []
for name, model in models:
kfold = KFold(n_splits=10, random_state=10)
score = cross_val_score(model, X, y, cv=kfold,
scoring=’accuracy’).mean()
names.append(name)
scores.append(score)
kf_cross_val = pd.DataFrame({‘Nama’: names, ‘Nilai’:
scores})
print(kf_cross_val)
34 Machine Learning dengan Python

Hasil program:
Nama Nilai
0 KNN 0.719787
1 SVC 0.656279
2 LR 0.766781
3 DT 0.696252
4 GNB 0.757021
5 RF 0.743265
6 GB 0.776427
Penjelasan: dengan K=10 dinyatakan pada variabel nsplit=10 maka diperoleh bahwa
LR masih tetap sebagai kandidat model terbaik untuk memodelkan data yang sudah
dibersihkan atau mempunyai 77.64% akurasi.
Langkah 19. Bagian ini merupakan bagian yang menampilkan tabel akurasi dengan
grafik dan kita menggunakan menu seabond untuk itu.
Program:
axis = sns.barplot(x = ‘Nama’, y = ‘Nilai’, data = kf_
cross_val)
axis.set(xlabel=’Klasifikasi’, ylabel=’Akurasi’)
for p in axis.patches:
tinggi = p.get_height()
axis.text(p.get_x() + p.get_width()/2, tinggi +
0.005, ‘{:1.4f}’.format(tinggi), ha=”center”)
plt.show()

j. Kesimpulan
Model dipilih adalah Logistik Regression (LR). Untuk itu, data selanjutnya diolah
menggunakan model ini. Oleh karena itu, sebelum melakukan LR kita harus
menyimpan data yang sudah dibersihkan dalam format *csv yang baru untuk
dilakukan pemodelan.
 Pengenalan Pembelajaran Mesin (Machine Learning) untuk Analisis Data 35

k. Catatan dan Saran

Perhatikan bahwa dalam penulisan di atas kita hanya belajar dalam membaca data,
membersihkan data, dan mengevaluasi data terhadap beberapa model sehingga
dapat dipilih secara otomatis atas model-model yang dipilih. Terdapat banyak model
yang sudah diujicobakan terhadap data tersebut di mana kita belum menelusuri
masing-masing model secara lebih detail, yaitu K-Nearest Neighbors, Support
Vector Classifier, Logistic Regression, Gaussian Naive Bayes, Random Forest
and Gradient Boost. Beberapa algoritma tersebut akan dibahas lebih lanjut pada
subbab dan bab selanjutnya. Pemilihan data terhadap model Logistic Regression
(LR) menunjukkan bahwa model yang lain dapat underfitting atau overfitting. Selain
memahami masing-masing model lebih detail maka hasil pemodelan terhadap data
dengan LR perlu diperhatikan lebih lanjut.

l. Proses Pemodelan Data yang Sudah Bersih

Setelah data dibersihkan, kita dapat langsung memproses pengolahan data pada
program yang baru dengan hasil identifikasi digunakan untuk langsung kembali
memanggil data.
Misalkan file program diberi nama Diabetesbersih.ipynb
Langkah 20
#https://towardsdatascience.com/machine-learning-
workflow-on-diabetes-data-part-01-573864fcc6b8
%matplotlib inline
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
diabetes =
pd.read_csv(‘E:/JAN2016/KULIAH20182019/SEM2_20182019/
ANALISA_DATA/PROJECTAnalisaData/diabetesIndo.csv’)
diabetes.columns
36 Machine Learning dengan Python

Langkah 21. Memanggil data yang bersih saja setelah observasi di atas
diabetes_mod = diabetes[(diabetes.Tekanandarah != 0) &
(diabetes.BMI != 0) & (diabetes.Glukosa != 0)]
print(diabetes_mod.shape)
Luaran
(724, 9)

Langkah 22. Menyimpannya dalam file:

#menyimpan data pada file Simpan. csv
diabetes_mod.to_csv(‘Cleandiabetes.csv’)
Selanjutnya kita dapat melakukan logistic Regression pada data yang diperoleh.

1.8. Algoritma KNN (K-Nearest Neighbors)

Algoritma KNN muncul karena adanya kemiripan yang cukup dekat. Algoritma ini bertahap
sebagai berikut:
1. Panggil data
2. Tetapkan K yang dipilih
3. Untuk setiap contoh data:
a. Hitung jarak antara data yang ditanyakan dengan contoh data
b. Urutkan jarak dan diberi indeks dari yang terendah hingga tertinggi
4. Pilihlah sebanyak K-pertama yang telah diurutkan tadi
5. Ambil label dari data terpilih nomor 4
6. Jika regresi, cari rata-ratanya
7. Jika klasifikasi, cari mode (label yang paling sering muncul)
Contoh 1.3
Misalkan ditanyakan pada sekelompok orang berdasarkan umur menyukai buah pepaya atau
tidak. Jika suka bertanda 1 dan jika tidak bertanda 0. Jenis ini merupakan data yang dapat
diklasifikasi di mana pelabelan adalah 0 atau misalkan hasil survei ditunjukkan pada tabel
berikut.
 Pengenalan Pembelajaran Mesin (Machine Learning) untuk Analisis Data 37

No Umur Suka/Tidak Pepaya

1 20 0
2 30 0
3 45 1
4 65 1
5 55 1
6 57 1
7 67 1

Bagaimana Memilih K yang Tepat?

Untuk memilih K yang tepat, algoritma KNN dikerjakan beberapa kali untuk nilai K yang berbeda
dan pilih K yang mereduksi error yang dijumpai. Cara praktis dalam memilih K sebagai berikut:
1. Setelah K diturunkan nilainya hingga mendekati 1, pendekatan kita menjadi berkurang
stabil. Misalkan K=1, dan titik yang ditanyai dikelilingi oleh beberapa tipe kelas. Karena
K=1, maka KNN dapat salah prediksi.
2. Sebaliknya, jika nilai K dinaikkan, dugaan kita menjadi lebih stabil karena banyaknya yang
terpilih/rata-rata sehingga dugaan lebih akurat. Akan tetapi jika error meningkat berarti K
terlalu jauh.
3. Pada kasus di mana pemilihan K adalahnya pengambilan banyaknya label yang paling
sering muncul, biasanya K diambil bilangan ganjil.
Kita akan menunjukkan contoh KNN secara bertahap dalam Machine learning (Web 5).

Tahap 1.
# hitung jarak Euclide dari data
from math import sqrt
# fungsi untuk menghitung jarak euclide antar 2 vektor
def euclidean_jarak(baris1, baris2):
jarak = 0.0
for i in range(len(baris1)-1):
jarak += (baris1[i] - baris2[i])**2
return sqrt(jarak)
38 Machine Learning dengan Python

# Data untuk menguji fungsi jarak

dataset = [[2.7810836,2.550537003,0],
[1.465489372,2.362125076,0],
[3.396561688,4.400293529,0],
[1.38807019,1.850220317,0],
[3.06407232,3.005305973,0],
[7.627531214,2.759262235,1],
[5.332441248,2.088626775,1],
[6.922596716,1.77106367,1],
[8.675418651,-0.242068655,1],
[7.673756466,3.508563011,1]]
baris0 = dataset[0]
for row in dataset:
jarak = euclidean_jarak(baris0, row)
print(jarak)
Luaran
0.0
1.3290173915275787
1.9494646655653247
1.5591439385540549
0.5356280721938492
4.850940186986411
2.592833759950511
4.214227042632867
6.522409988228337
4.985585382449795
Tahap 2.
# Kita kumpulkan yang paling dekat
def get_neighbors(train, test_row, num_neighbors):
 Pengenalan Pembelajaran Mesin (Machine Learning) untuk Analisis Data 39

distances = list()
for train_row in train:
dist = euclidean_jarak(test_row, train_row)
distances.append((train_row, dist))
distances.sort(key=lambda tup: tup[1])
neighbors = list()
for i in range(num_neighbors):
neighbors.append(distances[i][0])
return neighbors

Tahap 3. Kita uji

Fungsi jarak diuji
dataset = [[2.7810836,2.550537003,0],
[1.465489372,2.362125076,0],
[3.396561688,4.400293529,0],
[1.38807019,1.850220317,0],
[3.06407232,3.005305973,0],
[7.627531214,2.759262235,1],
[5.332441248,2.088626775,1],
[6.922596716,1.77106367,1],
[8.675418651,-0.242068655,1],
[7.673756466,3.508563011,1]]
neighbors = get_neighbors(dataset, dataset[0], 3)
for neighbor in neighbors:
print(neighbor)
Luaran
[2.7810836, 2.550537003, 0]
[3.06407232, 3.005305973, 0]
[1.465489372, 2.362125076, 0]
40 Machine Learning dengan Python

Tahap 4. Buat dugaan

#Membuat pengelompokan berdasarkan hasil
def predict_classification(train, test_row, num_
neighbors):
neighbors = get_neighbors(train, test_row, num_
neighbors)
output_values = [row[-1] for row in neighbors]
dugaan = max(set(output_values), key=output_values.
count)
return dugaan

Tahap 5.
#Data yang diuji
dataset = [[2.7810836,2.550537003,0],
[1.465489372,2.362125076,0],
[3.396561688,4.400293529,0],
[1.38807019,1.850220317,0],
[3.06407232,3.005305973,0],
[7.627531214,2.759262235,1],
[5.332441248,2.088626775,1],
[6.922596716,1.77106367,1],
[8.675418651,-0.242068655,1],
[7.673756466,3.508563011,1]]
dugaan = predict_classification(dataset, dataset[0], 3)
print(‘Yang diharapkan %d, Diperoleh %d.’ %
(dataset[0][-1], dugaan))
Luaran
Yang diharapkan 0, Diperoleh 0.
 Pengenalan Pembelajaran Mesin (Machine Learning) untuk Analisis Data 41

1.9. Metode Klasifikasi Bayes Naif (Naive Bayes Classification)

Metode Naive Bayes Classification (NBC) mengasumsikan bahwa adanya suatu variabel/
faktor dalam suatu kelas tidak terkait dengan faktor lain sekalipun kemungkinan saling
bergantung, semua sifat dianggap berkontribusi secara independen terhadap probabilitas
apakah faktor-faktor itu terkait atau tidak. Hal inilah mengapa digunakan istilah Naive. Pada
bagian ini, kita akan jelaskan lebih mendasar tentang NBC (Web 6).
Dalam teori statistik dan probabilitas, teorema Bayes menyatakan probabilitas suatu
kejadian berdasarkan pengetahuan sebelumnya (yang disebut prior) apakah suatu kondisi
berelasi dengan kejadian. Hal ini menyatakan probabilitas bersyarat. Misalkan kita menetapkan
suatu hipotesis (H) dan kejadian (E) maka teorema Bayes menyatakan hubungan probabilitas
hipotesis sebelum kejadian P(H) dan probabilitas dari hipotesis setelah terjadi kejadian E yang
ditulis P(H|E).
P H  PH 
PE 
PE

Di mana P(H|E) disebut probabilitas posterior. Faktor yang menghubungkan keduanya,

P H 
yaitu dikatakan rasio kemiripan (Likelihood Ratio/LR). Dengan suku ini, teorema Bayes
P E
menjelaskan bahwa probabilitas posterior sama dengan probabilitas prior dikalikan dengan
(LR). Agak membingungkan bukan? Hal ini akan dijelaskan dengan contoh.
Misalkan diambil kartu dan kita ingin menemukan probabilitas bahwa kartu yang diambil
adalah kartu berbentuk raja di mana yang diberikan adalah suatu kartu wajah. Berdasarkan
teorema Bayes, kita dapat menyelesaikan hal ini. Jadi kita perlu membuat probabilitas
P(raja) = 4/52 karena ada 4 kartu berbentuk raja dalam
1 paket kartu lengkap
P(wajah|raja) = 1 karena semua raja merupakan kartu
berbentuk wajah
P(wajah) = 12/52 karena ada 12 macam wajah dalam 1
paket kartu lengkap
Jadi P(raja|wajah) = (P(wajah|raja)P(raja))/P(wajah)
= 1 (4/52) / (12/52) = 4/12 =1/3.
42 Machine Learning dengan Python

Contoh 1.4 Misalkan kita akan memprediksi cuaca masa datang

Misalkan kita mempunyai daftar cuaca dan akan memutuskan bahwa kita akan bermain di luar
atau tidak berdasarkan data tersebut.

Bermain di luar
Hari ke- Cuaca Kelembapan Angin
Tidak (T)/Ya (Y)
H1 Panas Tinggi Lemah Tidak
H2 Panas Tinggi Kuat Tidak
H3 Nyaman Tinggi Lemah Ya
H4 Hujan Tinggi Lemah Ya
H5 Hujan Normal Lemah Ya
H6 Hujan Normal Lemah Ya
H7 Nyaman Normal Kuat Ya
H8 Panas Tinggi lemah Tidak
H9 Panas Normal Lemah Ya
H10 Hujan Normal Lemah Ya
H11 Panas Normal Kuat Ya
H12 Nyaman Tinggi Kuat Ya
H13 Nyaman Normal Lemah Ya
H14 Hujan Tinggi Kuat Tidak

Kemudian kita susun tabel frekuensi dengan setiap atribut dari data di atas

Tabel frekuensi Bermain di luar

Ya Tidak
Panas 3 2
Cuaca Nyaman 4 0
Hujan 3 2
 Pengenalan Pembelajaran Mesin (Machine Learning) untuk Analisis Data 43

Tabel frekuensi Bermain di luar

Ya Tidak
Tinggi 3 4
Kelembapan Normal 6 1

Tabel frekuensi Bermain di luar

Ya Tidak
Angin Kuat 6 2
Lemah 3 3

Untuk setiap tabel frekuensi, kita susun tabel likelihood.

P(xIc)=P(panas|ya)= Bermain P(x)=P(panas)=

3/10=0.3 Ya Tidak 5/14=0.36

Panas 3/10 2/4 5/14

Cuaca Nyaman 4/10 0/4 4/14

Hujan 3/10 2/4 5/14
10/14 4/14

P(c)=P(yes)=10/14=0.71

Jadi likelihood Ya, jika diketahui panas adalah:

P(c|x) =P(Ya|Panas) = P(Panas|Ya)*P(Ya)/P(Panas)

= (0.31)(0.71)/0.36 = 0.591

Secara sama, likelihood Tidak, jika diberikan situasi panas adalah:

P(c|x) =P(Tidak|Panas) = P(Panas|Tidak)*P(Tidak)/

P(Panas)
= (0.4)(0.36)/0.36 = 0.40
44 Machine Learning dengan Python

Secara sama, kita dapat menyusun tabel likelihood untuk atribut yang lain.

Tabel frekuensi Bermain di luar

Ya Tidak
Tinggi 3/9 4/5 7/14
Kelembapan Normal 6/9 1/5 7/14
9/14 5/14

Tabel frekuensi Bermain di luar

Ya Tidak
Angin Kuat 6/9 2/5 8/14
Lemah 3/9 3/5 6/14
9/14 5/14

Jadi dapat diperoleh likelihood Ya, jika kelembapan tinggi:

P(Ya|Tinggi) = (0.33)(0.6)/0.5 = 0.42

P(Tidak|Tinggi) = (0.8)(0.36)/0.5 = 0.58

Demikian pula likelihood terhadap atribut angin:

P(Ya|Lemah) = (0.67)(0.64)/0.57 = 0.75

P(Tidak|Lemah) = (0.4)(0.36)/).57 = 0.25

Kemudian kita mempunyai data suatu Hari (Hx) di mana:

Cuaca: Hujan
Kelembapan: Tinggi
Angin: Lemah
Pertanyaannya: Bermain di Luar (Ya/Tidak)?
Likelihood Ya pada hari itu adalah:
=P(Cuaca=Hujan|Ya)*P(Kelembaban=Tinggi|Ya)
*P(Angin=Lemah|Ya)
*P(Ya)
= 2/9 * 3/9 * 6/9 * 9/14 = 0.0199
 Pengenalan Pembelajaran Mesin (Machine Learning) untuk Analisis Data 45

Likelihood Tidak pada hari itu adalah:

P(Cuaca=Hujan|Tidak)*P(Kelembaban=Tinggi|tidak)
*P(Angin=Lemah|Tidak)*P(Tidak)
= 2/5 * 4/5 * 2/5 * 5/14 = 0.0166
Dengan menormalisasi nilai yang diperoleh maka
P(Ya) = 0.0199 / (0.0199+ 0.0166) = 0.55
P(Tidak) = 0.0166 / (0.0199+ 0.0166) = 0.45
Jadi, dari data disimpulkan bahwa terdapat 55% kesempatan untuk bermain di luar pada hari
tersebut.

1.9.1. Penggunaan Bayes pada Industri

Pada bagian ini, kita akan melihat beberapa contoh industri dengan Bayes, misalkan dalam
kasus kategorisasi berita ataupun klasifikasi teks. Berita dalam web sangat cepat di mana
setiap bagian berita berbeda layout dan kategorisasi grup berita. Perusahaan menggunakan
web crawler untuk mengekstrak teks yang bermakna dari HTML. Untuk mendapatkan hasil
klasifikasi yang lebih baik, kata-kata yang tidak penting dibuang. Pada kasus ini, digunakan
NBC untuk mengklasifikasi konten berita.
NBC merupakan teknik yang populer dalam melakukan filtering e-mail. Biasanya, NBC
menggunakan kumpulan kata-kata/faktor yang mengidentifikasi e-mail sampah (spam), dengan
pendekatan klasifikasi teks yang umum digunakan. NBC bekerja dengan menghubungkan
penggunaan token (biasanya kata-kata, atau yang lain) dengan spam atau bukan spam
kemudian menggunakan teorema Bayes, dihitung probabilitas apakah suatu e-mail spam atau
tidak.
Kata-kata tertentu mempunyai probabilitas tertentu yang terjadi pada e-mail spam,
misalkan sebagian besar pengguna e-mail sering menggunakan kata Lottery atau Luck Draw
pada e-mail bertipe spam, tetapi jarang digunakan pada e-mail yang bukan spam. Setiap kata
dalam e-mail berkontribusi pada probabilitas e-mail berjenis spam atau kata-kata yang paling
menarik. Kontribusi demikian disebut probabilitas posterior dan dihitung dengan teorema
Bayes. Probabilitas e-mail yang bertipe spam dihitung untuk semua kata dalam e-mail dan jika
melebihi batas ambang (95%) maka filter akan menandai bahwa e-mail tersebut spam.
Pada diagnosis medis, rumah sakit-rumah sakit modern dilengkapi dengan monitor
dan alat-alat pengumpul data yang menghasilkan sangat banyak data yang terkumpul untuk
melakukan pengujian medis dan perlakuan medis. Salah satu keuntungan utama dalam
46 Machine Learning dengan Python

NBC yang muncul bagi para dokter adalah bahwa semua informasi yang digunakan untuk
menjelaskan keputusan. Diagnosis dan prognosis medis dapat dilakukan untuk memberikan
diagnosis kepada pasien.
Ketika terdapat data medis, NBC memedulikan kejadian dengan banyak atribut untuk
membuat prediksi akhir dan memberikan penjelasan secara transparan untuk keputusan-
keputusan yang dibuat. Oleh karena itu, NBC dipandang sebagai salah satu klasifikasi yang
paling sangat berguna bagi kalangan dokter.

1.9.2. Navier Bayes Classifier (NBC) dengan Python

Pada bagian ini, akan ditunjukkan NBC dengan Python tahap demi tahap.
Contoh 1.5 Menghitung jarak Euclid

Tahap 1. Contoh menghitung data dalam radius tertentu

#https://github.com/lucko515/breast-cancer-
classification/blob/master/NaiveBayesClassifier.ipynb
#importing libs
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
#Untuk mengajarkan bagaimana menghitung jarak antar
data
X = np.array([[1, 3],[4, 6],[3, 2],[7, 5],[7, 6]])
for i in range(len(X)):
plt.scatter(X[i][1], X[i][0])

plt.scatter(3, 4, color=’red’)
circle = plt.Circle((3, 4), radius=2, alpha=0.4)
plt.gca().add_patch(circle)
plt.axis(‘scaled’)
plt.show()
 Pengenalan Pembelajaran Mesin (Machine Learning) untuk Analisis Data 47

jarakEuclid = np.sqrt((3-2)**2 + (4-3)**2)

print(jarakEuclid )
Luaran

Contoh 1.6 Program file: NaiveBayesBC.py

Tahap 2. Sambungkan program ini dengan file di atas
class NaiveBayesClassifier(object):
def __init__(self):
pass

#Input: X - faktor dalam data training

# y - Label dalam data trainiing
def fit(self, X, y):
self.X_train = X
self.y_train = y

self.no_of_classes = np.max(self.y_train) + 1

# fungsi untuk menghitung semua titi/contoh data

dalam radius yang dipenuhi
def euclidianDistance(self, Xtest, Xtrain):
return np.sqrt(np.sum(np.power((Xtest -
Xtrain), 2)))

# Ini adalah fungsi utama untuk melakukan prediksi

# semua perhitungan menggunakan contoh data uji
yang baru
# Terdapat 4 tahap untuk dilakukan
48 Machine Learning dengan Python

# 1. Hitung Probabilitas prior, contoh P(A)

=banyaknya elemen dalam 1 klas/ total sampel
#.2 Hitung probabilitas Margin P(X) = banyaknya
elemen dalam radius(lingkaran) / total sampel
# 3. Hitung likelihood (P(X|A) = banyaknya elemen
dalam klas yang dihitung/ total sampel
# 4. Hitung probabilitas posterior =P(A|X) =
(P(X|A) * P(A)) / P(X)
#Kerjakan semua tahap itu untuk semua klas dalam
himpunan data

#
#Input: X - himpunan data uji
#
# radius = parameter yangmenyatakan seberapa besar
lingkaran untuk data yang baru, default=2
def predict(self, X, radius=0.4):
pred = []

#Membuat list/daftar banyaknya element untuk

setiap klass dalam datalatih (trainset)
members_of_class = []
for i in range(self.no_of_classes):
counter = 0
for j in range(len(self.y_train)):
if self.y_train[j] == i:
counter += 1
members_of_class.append(counter)

#Memasuki proses dalam memprediksi

 Pengenalan Pembelajaran Mesin (Machine Learning) untuk Analisis Data 49

for t in range(len(X)):
#Membuat list kosong untuk setiap
probabilitas klas
prob_of_classes = []
#Looping pada setiap klass dalam data
for i in range(self.no_of_classes):

#1. step : probabilitas prior

P(class)=banyaknya elemen dalam klas/ total elemen
prior_prob = members_of_class[i]/
len(self.y_train)

#Step : Probabilitas margin P(X) =

banyaknya elemen dalam radius(lingkaran)/banyaknya
elemen
# Catatan : Pada looping informasi
yang sama untuk step 3
inRadius_no = 0
# Menghitung banyaknya titik dalam
klas yang dicermati dalam lingkaran
inRadius_no_current_class = 0

for j in range(len(self.X_train)):
if self.euclidianDistance(X[t],
self.X_train[j]) < radius:
inRadius_no += 1
if self.y_train[j] == i:
inRadius_no_current_class
+= 1

#Menghitung probabilitas margin

50 Machine Learning dengan Python

margin_prob = inRadius_no/len(self.X_
train)
#3. step : likelihood P(X|currect_
class) - banyaknya element dalam klas sekarang/total
element
likelihood = inRadius_no_current_
class/len(self.X_train)

# 4. step : Probabilitas posterioe

formula dari teorema Bayes
# P(currect_class|X)=
(likelihood*prior_prob)/margin_prob

post_prob = (likelihood * prior_prob)/

margin_prob
prob_of_classes.append(post_prob)

# dapatkan indeks dengan element terbesar(

klass dengan probabilitas terbesar)
pred.append(np.argmax(prob_of_classes))

return pred
Tahap 3. Menyusun fungsi untuk menguji akurasi
Lanjutkan pada file di atas
def akurasi(y_tes, y_pred):
benar = 0
for i in range(len(y_pred)):
if(y_tes[i] == y_pred[i]):
benar += 1
return (benar/len(y_tes))*100
 Pengenalan Pembelajaran Mesin (Machine Learning) untuk Analisis Data 51

Tahap 4.a Lanjutkan dalam file di atas, untuk menguji Naive Bayes yang dibuat.
Perhatikan bahwa kasus yang diujicobakan adalah file Social_Network_Ads.csv yang dapat
diperoleh dari internet dengan kata ini.
Tujuan dari data tersebut adalah untuk mempelajari apakah konsumen memesan atau tidak
untuk suatu barang.
Sebagian bentuk data berisi berikut ini:
User ID,Gender,Age,EstimatedSalary,Purchased
15624510,Male,19,19000,0
15810944,Male,35,20000,0
15668575,Female,26,43000,0
15603246,Female,27,57000,0
15804002,Male,19,76000,0
15728773,Male,27,58000,0
15598044,Female,27,84000,0
15694829,Female,32,150000,1
15600575,Male,25,33000,0
15727311,Female,35,65000,0
15570769,Female,26,80000,0
15606274,Female,26,52000,0

Kita dapat mencermati bagaimana isi data, berapa baris dan berapa kolom dengan perintah
berikut:
#Kita ingin mempelajari data file di atas (karena dalam
fungsi run, kita tidak bisa panggil,
#sehingga diulang panggil)
dataset = pd.read_csv(‘Social_Network_Ads.csv’)
X = dataset.iloc[:, [2, 3]].values
y = dataset.iloc[:, 4].values
dataset.columns
dataset.head()
52 Machine Learning dengan Python

print(“Dimensi data : {}”.format(dataset.shape))

Luaran
Dimensi data : (400, 5)

Tahap 4.b
Kita melanjutkan diskusi kita untuk mencoba melakukan pengujian program NBC yang dibuat
untuk file data ‘Social_Network_Ads.csv’
def run():
# Data dicoba
dataset = pd.read_csv(‘Social_Network_Ads.csv’)
X = dataset.iloc[:, [2, 3]].values
y = dataset.iloc[:, 4].values
#Pemisahan data menjadi data latih (training set
dan data uji (test set))
# from sklearn.model_selection import model_
selection
from sklearn.model_selection import train_test_
split
X_train, X_test, y_train, y_test = train_test_
split(X, y, test_size = 0.25, random_state = 0)

# Penyekalaan faktor-faktor
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)

#Menguji Naive Bayes Classifier yang dibuat

NB = NaiveBayesClassifier()
 Pengenalan Pembelajaran Mesin (Machine Learning) untuk Analisis Data 53

NB.fit(X_train, y_train)

y_pred = NB.predict(X_test, radius=0.4)

#sklearn
from sklearn.naive_bayes import GaussianNB
NB_sk = GaussianNB()
NB_sk.fit(X_train, y_train)

sk_pred = NB_sk.predict(X_test)
print(“Akurasi untuk NBC disini adalah: “,
akurasi(y_test, y_pred), “%”)
print(“Akurasi NBC dari sklearn: “,akurasi(y_test,
sk_pred), “%”)

run()

Luaran:
Akurasi untuk NBC disini adalah: 93.0 %
Akurasi NBC dari sklearn: 90.0 %

Tahap 5.
Kita akan melakukan pengujian NBC yang dibuat untuk data breast cancer di mana nama file
data breastCancer.csv yang dapat diperoleh dari internet (Web 7). Yang perlu diperhatikan
terdapat beberapa jenis file pengukuran untuk breastCancer sehingga pembaca perlu
mencermati karena program mengikuti bentuk data pada file. Beberapa baris pertama data
ditulis berisi berikut ini.
“id”,”clump_thickness”,”size_uniformity”,”shape_
uniformity”,”marginal_adhesion”,”epithelial_
size”,”bare_nucleoli”,”bland_chromatin”,”normal_
nucleoli”,”mitoses”,”class”
54 Machine Learning dengan Python

1000025,5,1,1,1,2,1,3,1,1,2
1002945,5,4,4,5,7,10,3,2,1,2
1015425,3,1,1,1,2,2,3,1,1,2
1016277,6,8,8,1,3,4,3,7,1,2
1017023,4,1,1,3,2,1,3,1,1,2
1017122,8,10,10,8,7,10,9,7,1,4
1018099,1,1,1,1,2,10,3,1,1,2
1018561,2,1,2,1,2,1,3,1,1,2
1033078,2,1,1,1,2,1,1,1,5,2
1033078,4,2,1,1,2,1,2,1,1,2

Perhatikan bahwa class didefinisikan dengan label 2 dan 4. Untuk itu, beberapa baris dalam
program mengonversi label 2 menjadi 0 dan yang berlabel 4 menjadi 1.

Program secara keseluruhan dalam fungsi berikut:

#Pengujian terhadap Breast Cancer dataset
def breastCancerTest():
# Importing the dataset
dataset = pd.read_csv(‘breastCancer.csv’)
dataset.replace(‘?’, 0, inplace=True)
dataset = dataset.applymap(np.int64)
X = dataset.iloc[:, 1:-1].values
y = dataset.iloc[:, -1].values
#Bagian ini penting karena banyaknya faktor
merupakan bagian dari algoritma dan
# pada data ini classes ditandai 2 dan 4
y_new = []
for i in range(len(y)):
if y[i] == 2:
y_new.append(0)
else:
 Pengenalan Pembelajaran Mesin (Machine Learning) untuk Analisis Data 55

y_new.append(1)
y_new = np.array(y_new)

# Pemisahan data dari data uji dan data latih

from sklearn.model_selection import train_test_
split
X_train, X_test, y_train, y_test = train_test_
split(X, y, test_size = 0.25, random_state = 0)

#Pengujian NBC yang dibuat

NB = NaiveBayesClassifier()
NB.fit(X_train, y_train)

y_pred = NB.predict(X_test, radius=8)

#sklearn
from sklearn.naive_bayes import GaussianNB
NB_sk = GaussianNB()
NB_sk.fit(X_train, y_train)
sk_pred = NB_sk.predict(X_test)
print(“Akurasi untuk NBC yang dibuat: “,
akurasi(y_test, y_pred), “%”)
print(“Akurasi untuk NBC dari sklearn:
“,akurasi(y_test, sk_pred), “%”)
from sklearn import metrics
print(‘Rata error absolut:’, metrics.mean_
absolute_error(y_test, y_pred))
print(‘Kuadrat error rerata:’, metrics.mean_
squared_error(y_test, y_pred))
56 Machine Learning dengan Python

print(‘Akar kuadrat error rerata:’,

np.sqrt(metrics.mean_squared_error(y_test, y_pred)))

Kemudian untuk menjalankan program, tuliskan nama fungsi di atas:

breastCancerTest()
Luaran:
Akurasi untuk NBC yang dibuat: 96.57142857142857 %
Akurasi untuk NBC dari sklearn: 95.42857142857143 %
Rata error absolut: 0.06857142857142857
Kuadrat error rerata: 0.13714285714285715
Akar kuadrat error rerata: 0.3703280399090206

Penjelasan lebih lanjut hasil program:

Tentunya, kita ingin mengetahui manakah yang salah klasifikasi sehingga terdapat kesalahan.
Hal ini dapat dilakukan dengan menyusun selisih dari y prediksi dan y uji di mana 2 variabel ini
berisi label. Dengan menyusun selisihnya pada program berikut.

z = y_pred-y_test

Diperoleh luaran:

[ 0 0 2 0 0 0 0 0 0 -2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 -2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 -2 0 0 0 0 0 0 0 0 0 0 0 0 0
0 -2 0 0 0 0 0 0 0 0 0 0 0 0]

Jadi diperoleh 6 titik salah klasifikasi.

 Pengenalan Pembelajaran Mesin (Machine Learning) untuk Analisis Data 57

Ringkasan Bab I
Pada bagian ini, telah dijelaskan tentang Machine Learning (ML), bagaimana kaitan ML
dengan ilmu-ilmu yang lain. Selain itu, ditunjukkan pula langkah-langkah yang dilakukan
dalam Machine Learning. Agar pembaca dapat memahami dengan mudah pada implementasi
Machine Learning, pada bab ini telah ditunjukkan beberapa algoritma untuk mempelajari
data dengan maksud pembaca mendapat praktik langsung terhadap cara kerja algoritma
dalam ML. Penjelasan lebih lanjut terhadap masing-masing algoritma ditunjukkan pada bab-
bab selanjutnya. Beberapa hal secara detail tentang Machine Learning tidak dibahas dalam
buku ini karena buku ini memberikan pengantar bagi pembaca untuk dapat terjun langsung
menggunakan algoritma yang telah disediakan dalam program Python, serta mengembangkan
sendiri penggunaannya terhadap kasus yang dihadapi.

DAFTAR PUSTAKA
Alonso-Robisco, A., & Carbó, J. M. 2022. Can Machine Learning Models Save Capital for
Banks? Evidence from a Spanish Credit Portfolio. International Review of Financial
Analysis, 84 (November), 1–8. https://doi.org/10.1016/j.irfa.2022.102372.
An, C., Lim, H., Kim, D. W., Chang, J. H., Choi, Y. J., & Kim, S. W. 2020. Machine Learning
Prediction for Mortality of Patients Diagnosed with Covid-19: A Nationwide Korean Cohort
Study. Scientific Reports, 10(1), 1–11. https://doi.org/10.1038/s41598-020-75767-2.
Dönmez, P. 2013. Introduction to Machine Learning. In A. Ethem (Ed.), Natural Language
Engineering (Vol. 19, Issue 2). https://doi.org/10.1017/s1351324912000290.
Ghada, H., Mohammed, A. E.-R. M., & Safaa El-Sayed, Amin, Mohamed Fahmy, T. 2020. Deep
Learning in Breast Cancer Detection and Classification. Proceedings of the International
Conference on Artificial Intelligence and Computer Vision AICV 2020, 322–333. https://
link.springer.com/book/10.1007/978-3-030-44289-7.
Guégan, D., & Hassani, B. 2018. Regulatory Learning: How to Supervise Machine Learning
Models? An Application to Credit Scoring. Journal of Finance and Data Science, 4(3),
157–171. https://doi.org/10.1016/j.jfds.2018.04.001.
Huber, J., & Stuckenschmidt, H. 2020. Daily Retail Demand Forecasting Using Machine
Learning with Emphasis on Calendric Special Days. International Journal of Forecasting,
36(4), 1420–1438. https://doi.org/10.1016/j.ijforecast.2020.02.005.
58 Machine Learning dengan Python

Kalfin, Sukono, Supian, S., & Mamat, M. 2022. Insurance Premium Determination Model and
Innovation for Economic Recovery Due to Natural Disasters in Indonesia. Computation,
10 (10). https://doi.org/10.3390/computation10100174.
Mohammed, M., Khan, M. B., & Bashie, E. B. M. 2017. Machine Learning: Algorithms and
Applications. In Machine Learning: Algorithms and Applications (Issue December).
https://doi.org/10.1201/9781315371658.
Parhusip, H. A., Susanto, B., Linawati, L., & Trihandaru, S. 2020. Classification Breast Cancer
Revisited with Machine Learning. 1 (1), 33–41.
Shirmard, H., Farahbakhsh, E., & Chandra, R. 2022. A Review of Machine Learning in
Processing Remote Sensing Data for Mineral Exploration. 268 (January), 4–7. https://
doi.org/https://doi.org/10.1016/j.rse.2021.112750.
Vasileios, L., Maria, D., Panagiotis, T., & Yannis L, K. 2022. Machine Learning in Disaster
Management: Recent Developments in Methods and Applications. Mach. Learn. Knowl.
Extr, 4 (2), 446–473. https://doi.org/https://doi.org/10.3390/make4020020.
BAB 2
METODE KLASTER
BERDASARKAN PUSAT

2.1. Pendahuluan
Salah satu metode klaster yang dikenal adalah metode klaster berdasarkan pusat yang sering
disebut K-Means Clustering. Ide algoritma K-Means adalah diberikan pengelompokan awal,
tetapi tidak optimal. Kemudian pindahkan setiap titik ke pusat terdekat yang baru, perbarui
pusat pengelompokan dengan menghitung rata-rata titik anggota, dan ulangi proses relokasi
dan pembaharuan hingga kriteria konvergensi (seperti jumlah iterasi yang telah ditentukan,
perbedaan nilai fungsi distorsi) terpenuhi. Kita akan mempelajari contoh penggunaan ide
K-Means data pada bidang (Dabbura, 2018), sedangkan beberapa aplikasi, pembaca dapat
membaca dari beberapa hasil penelitian para peneliti (Li & Wu, 2012) (Kobylin & Lyashenko,
2020), serta aplikasi K-means pada pengelompokan untuk data Covid-19 (Virgantari &
Faridhan, 2020).
1. Tetapkan banyaknya klaster (K)
Misal pilih K = 2. Titik secara random sebagai pusat klaster ditandai dengan kotak pada
Gambar 2.1.
60 Machine Learning dengan Python

Gambar 2.1 Ilustrasi pusat klaster terhadap anggota yang lain pada K-Means

2. Awali pusat klaster secara random.

3. Lakukan iterasi hingga tidak ada perubahan pusat data, dengan cara:
a. Hitung jumlah kuadrat jarak antara data dengan semua pusat.
b. Tetapkan setiap data yang berbeda pada pusat klaster terdekat.
c. Tentukan pusat klaster dari rata-rata data pada tiap klaster.

Gambar 2.2 Ilustrasi pusat klaster perpindahan pusat klaster pada iterasi tertentu terhadap anggota
yang lain pada K-Means

Pendekatan ini disebut prinsip Expectation-Maximization (EM). Langkah E menyatakan

penugasan data pada klaster terdekat dan langkah M menyatakan untuk menghitung fungsi
tujuan, yaitu:
m K
J w
i 1 k 1
ik  x i  k 2  . (2.1)
 Metode Klaster Berdasarkan Pusat 61

Pada bagian ini merupakan masalah optimasi dalam meminimalkan menjadi 2 bagian.
Peminimalan pertama adalah meminimalkan J terhadap w ik di mana k dipilih tetap. Kemudian
meminimalkan J terhadap k di mana w ik dipilih tetap. Secara teknis, kita menurunkan J
terhadap w ik kemudian klaster diperbarui (langkah-E). Selanjutnya, J diturunkan terhadap k
dan pusat klaster diulang dihitung berdasarkan klaster yang sebelumnya diperoleh (langkah
M). Jadi langkah E adalah:
m K
J
w ik
   x
i 1 k 1
i
 k 2  (2.2)

 argmin
1 jika k   xi   j 2 
Di mana w ik   j .
 0, lainnya


Hal ini berarti menempatkan data x i pada klaster terdekat yang ditempatkan berdasarkan
jumlah jarak kuadrat terhadap pusat klaster, sedangkan langkah M dilakukan dengan
menghitung:
m

  
J
 2 w ik x i  k  0 (2.3)
k i 1

 w x
m i
i 1 ik
sehingga k  .
 w
m
i 1 ik

Hal ini menunjukkan menghitung kembali pusat klaster untuk menjelaskan penugasan
baru. Perlu dicatat: karena algoritma klaster K-means menggunakan pengukuran jarak untuk
menentukan kesamaan data maka disarankan data distandardisasi sehingga mempunyai rata-
rata nol dan standar deviasi 1 karena hampir selalu setiap atribut/variabel mempunyai satuan
yang berbeda, seperti umur dan gaji.
Diberikan K-means secara natural iteratif dan pusat klaster diawali random. Oleh karena
itu, pusat awal berbeda akan memberikan hasil klaster berbeda karena algoritma K-means
akan bermasalah pada optimum lokal dan bisa tidak mendapat konvergen global optimum.
Oleh karena itu, disarankan menjalankan algoritma dengan pusat klaster awal yang berbeda-
beda dan diambil yang mempunyai jarak kuadrat paling minimum.
62 Machine Learning dengan Python

2.2. K-Means dengan Python

K-Means clustering adalah algoritma mesin pembelajaran tak terbimbing (unsupervised
machine learning) yang berarti K-means mengklasifikasi data tanpa memberi pelabelan data/
tanpa variabel target/tanpa variabel dependen. Aplikasi K-means, misalnya meliputi profil
konsumen, segmentasi pasar, computer vision, pemilihan mesin dan astronomi, maupun pada
bidang medis. Dalam melakukan K-means dapat terjadi kita sulit untuk menetapkan berapa
banyaknya klaster. Dalam melakukan clustering dengan Python maka modul yang perlu
digunakan dari Python adalah:
1. Numpy: jika menggunakan array yang multidimensi.
2. Pandas: untuk mengorganisasi data dalam bentuk tabel.
3. Matplotlib: untuk memvisualisasikan data dalam numpy.
4. Seaborn: Sebagai modul pendukung visualisasi dengan Matplotlib.
5. Scikit-learn: modul yang paling sering digunakan dalam pembelajaran mesin.

2.2.1. Pemilihan Banyaknya Klaster

Sering kali data berdimensi banyak sehingga susah divisualisasikan. Oleh karena itu,
banyaknya klaster menjadi tidak jelas. Akan tetapi, secara matematis, hal ini dapat dilakukan.
Kita akan menghubungkan banyaknya klaster dengan Within Cluster Sum of Squares (WCSS)
dengan memilih banyaknya klaster di mana WCSS kemudian bernilai turun (metode Elbow),
yaitu:
m

x  ci 
2
WCSS  i (2.4)
i 1

Metode Elbow akan menghasilkan iterasi yang menyebabkan WCSS menuju nol sebagaimana
ditunjukkan pada Gambar 2.3.
 Metode Klaster Berdasarkan Pusat 63

Gambar 2.3 Iterasi metode Elbow terhadap nilai WCSS yang menunjukkan konvergensi

Gambar 2.4 Klaster mula-mula (kiri) dan hasil klaster (kanan) pada K-Means

2.3. Contoh Pemrograman K-Means Clustering

2.3.1. Dengan Daftar Data dalam 2 Klaster

Pada bagian ini, diambil dari daftar pustaka (https://datatofish.com/k-means-clustering-python/)
dengan melakukan penyesuaian.
64 Machine Learning dengan Python

Langkah 1. Menampilkan data

import numpy as np
import matplotlib.pyplot as plt
from matplotlib import style
style.use(“ggplot”)
from sklearn.cluster import KMeans

x = [1,5,1.5,8,1,9]
y = [2,8,1.8,8,.6,11]

plt.scatter(x,y)
plt.show()

Gambar 2.5 Penampilan data yang akan di klaster

X =
np.array([[1,2],[5,8],[1.5,1.8],[8,8],[1,.6],[9,11]])
kmeans = KMeans(n_clusters=2)
kmeans.fit(X)
 Metode Klaster Berdasarkan Pusat 65

centroids = kmeans.cluster_centers_
labels = kmeans.labels_
print(centroids)
print(labels)
colors = [‘r’,’b’,’y’,’g’,’c’,’m’]
for i in range(len(X)):
print(“koordinat:”,X[i], “label:”, labels[i])
plt.plot(X[i][0], X[i][1], colors[labels[i]],
markersize = 10)
plt.scatter(centroids[:, 0],centroids[:, 1], marker =
“x”, s=150, linewidths = 5, zorder = 10)
plt.show()
plt.scatter(x,y)
plt.scatter(centroids[:, 0],centroids[:, 1], marker =
“x”, s=150, linewidths = 5, zorder = 10)
plt.show()

Langkah 2. Melakukan clustering

Pusat setiap klaster menyatakan rata-rata observasi setiap klaster data yang dekat dengan
klaster yang diberikan dekat dengan pusat klaster.
Luaran:
[[1.16666667 1.46666667]
[7.33333333 9. ]] [0 1 0 1 0 1]
koordinat: [1. 2.] label: 0
koordinat: [5. 8.] label: 1
koordinat: [1.5 1.8] label: 0
koordinat: [8. 8.] label: 1
koordinat: [1. 0.6] label: 0
koordinat: [ 9. 11.] label: 1
66 Machine Learning dengan Python

Gambar 2.6 Penampilan data yang akan di klaster dan pusat klaster pada awal iterasi

Kita akan melihat K-Means Clustering dengan Python – 4 clusters.

Kasus yang sama diubah dalam 4 klaster. Tentu agak tidak masuk akal karena data terlalu
sedikit untuk menjadi 4 klaster. Tetapi sebagai contoh, kita membuat menjadi 4 klaster pada
program di atas cukup menggantikan pada baris berikut:

kmeans = KMeans(n_clusters=4)

Diperoleh hasil gambar pada Gambar 2.7.

Gambar 2.7 Penampilan data yang akan di klaster dan pusat klaster pada awal selanjutnya setelah
proses dengan hasil Gambar 2.6
 Metode Klaster Berdasarkan Pusat 67

Contoh 2.2
Kita akan mencoba melakukan clustering terhadap data kasus positif Covid-19 dan yang
sembuh di semua provinsi pada 2 hari berturutan, yaitu pada 22 April 2020 dan 23 April 2020.
Yang menjadi masalah: apakah terjadi pola pengelompokan?

Langkah 1. Data disimpan pada Cov11Ap.csv, kemudian data dipanggil

#https://mubaris.com/posts/kmeans-clustering/
#Program digunakan untuk clustering data Covid 19 Indo
11 April 2020,
#34 propinsi untuk kasus positif (kolom1) dan sembuh
(kolom 2)
%matplotlib inline
from copy import deepcopy
import numpy as np
import pandas as pd
from matplotlib import pyplot as plt
plt.rcParams[‘figure.figsize’] = (16, 9)
plt.style.use(‘ggplot’)
# Importing the dataset
data = pd.read_csv(‘Cov11Ap.csv’)
print(data.shape)
data.head()
Luaran:

Langkah 2.
# Tulis nilai dan gambar
f1 = data[‘V1’].values
f2 = data[‘V2’].values
X = np.array(list(zip(f1, f2)))
plt.scatter(f1, f2, c=’black’, s=50)

Luaran:
68 Machine Learning dengan Python

Gambar 2.8 Penampilan data yang akan di klaster yang mengelompok pada 2 lokasi

Sekilas terlihat bahwa data mengumpul pada 2 kelompok dengan 1 kelompok 2 anggota
pada ujung kanan atas. Kita akan coba bagaimana menyusun klaster dengan K-Means.
Andaikan dianggap banyaknya klaster 3.

Langkah 3.
# Hitung jarak Euclid
def dist(a, b, ax=1):
return np.linalg.norm(a - b, axis=ax)
# banyaknya klater
k = 3
# X koordinat random pusat klaster
C_x = np.random.randint(0, np.max(X)-20, size=k)
# Y koordinat y untuk pusat
C_y = np.random.randint(0, np.max(X)-20, size=k)
C = np.array(list(zip(C_x, C_y)), dtype=np.float32)
print(C)
Luaran:
 Metode Klaster Berdasarkan Pusat 69

[[ 159. 3279.]
[ 817. 3022.]
[3463. 2461.]]

Langkah 4.
# Gambarkan data dengan pusat klaster
plt.scatter(f1, f2, c=’#050505’, s=50)
plt.scatter(C_x, C_y, marker=’*’, s=200, c=’g’)

Gambar 2.9 Penampilan data yang akan di klaster yang mengelompok pada 2 lokasi serta penentuan
titik pusat klaster

Pada langkah 4 ditunjukkan bahwa pusat klaster yang dibuat tidak pada sekitar data. Hal
inilah yang menyebabkan K-Means standar perlu diperbaiki. Jika proses iterasi dilanjutkan
maka clustering tidak terjadi.
Melakukan clustering yang sama, tetapi dengan cara yang berbeda (manual). Data clustering
menggunakan metode K-Means Clustering ini secara umum dilakukan dengan algoritma dasar
sebagai berikut:
1. Tentukan jumlah cluster.
2. Alokasikan data ke dalam cluster secara random.
3. Hitung centroid/rata-rata dari data yang ada di masing-masing cluster.
4. Alokasikan masing- masing data ke pusat/rata-rata terdekat.
70 Machine Learning dengan Python

Kembali ke Step 3, apabila masih ada data yang berpindah cluster atau apabila perubahan
nilai centroid, ada yang di atas nilai threshold yang ditentukan atau apabila perubahan nilai pada
fungsi tujuan yang digunakan di atas nilai threshold yang ditentukan.

Contoh 2.3
Langkah 1. Memanggil Librari
Program:
# Inisialisasi
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

Langkah 2. Visualisasi Data

df = pd.DataFrame({
‘x’: [1, 5, 7, 6.5, 9.5, 13.75, 17.15, 14, 12, 16],
‘y’:[3, 2, 4, 1.5, 6.25, 8.5, 11.25, 10.6, 8, 19.5]})

np.random.seed(200)
k = 3
# pusat[i] = [x, y]
pusat = {i+1: [np.random.randint(0, 25), np.random.
randint(0, 25)]for i in range(k)}
fig = plt.figure
plt.scatter(df[‘x’], df[‘y’], color=’k’,)
colmap = {1: ‘r’, 2: ‘r’, 3: ‘r’}
for i in pusat.keys():
plt.scatter(*pusat[i], color=colmap[i],
marker=’*’,s=50)
plt.xlim(0, 20)
 Metode Klaster Berdasarkan Pusat 71

plt.ylim(0, 20)
plt.show()

Gambar 2.10 Penampilan data yang akan di klaster dengan pusat klaster yang diletakkan random
untuk kasus Contoh 2.3

Sekilas terlihat bahwa data mengumpul pada 2 kelompok dengan 1 kelompok 2 anggota
pada ujung kanan atas. Kita akan coba bagaimana menyusun klaster dengan K-Means.
Andaikan dianggap banyaknya klaster 3.

Langkah 3.
# Hitung jarak Euclid
def dist(a, b, ax=1):
return np.linalg.norm(a - b, axis=ax)
# banyaknya klater
k = 3
72 Machine Learning dengan Python

# X koordinat random pusat klaster

C_x = np.random.randint(0, np.max(X)-20, size=k)
# Y koordinat y untuk pusat
C_y = np.random.randint(0, np.max(X)-20, size=k)
C = np.array(list(zip(C_x, C_y)), dtype=np.float32)
print(C)
Luaran:
[[ 159. 3279.]
[ 817. 3022.]
[3463. 2461.]]

Langkah 4.
#Gambarkan data dengan pusat klaster
plt.scatter(f1, f2, c=’#050505’, s=50)
plt.scatter(C_x, C_y, marker=’*’, s=200, c=’g’)
 Metode Klaster Berdasarkan Pusat 73

Pada langkah 4 ditunjukkan bahwa pusat klaster yang dibuat tidak pada sekitar data. Hal
inilah yang menyebabkan K-Means standard perlu diperbaiki. Jika proses iterasi dilanjutkan
maka clustering tidak terjadi.
Melakukan clustering yang sama, tetapi dengan cara yang berbeda (manual). Data clustering
menggunakan metode K-Means Clustering ini secara umum dilakukan dengan algoritma dasar
sebagai berikut:
1. Tentukan jumlah cluster.
2. Alokasikan data ke dalam cluster secara random.
3. Hitung centroid/rata-rata dari data yang ada di masing- masing cluster.
4. Alokasikan masing- masing data ke pusat/rata-rata terdekat.
Kembali ke Step 3, apabila masih ada data yang berpindah cluster atau apabila perubahan
nilai centroid, ada yang di atas nilai threshold yang ditentukan atau apabila perubahan nilai pada
fungsi tujuan yang digunakan di atas nilai threshold yang ditentukan.

Contoh 2.4
Program:
# Inisialisasi
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

df = pd.DataFrame({
‘x’: [1, 5, 7, 6.5, 9.5, 13.75, 17.15, 14, 12, 16],
‘y’:[3, 2, 4, 1.5, 6.25, 8.5, 11.25, 10.6, 8, 19.5]})

np.random.seed(200)
k = 3
# pusat[i] = [x, y]
pusat = {i+1: [np.random.randint(0, 25), np.random.
randint(0, 25)]for i in range(k)}
74 Machine Learning dengan Python

fig = plt.figure
plt.scatter(df[‘x’], df[‘y’], color=’k’,)
colmap = {1: ‘r’, 2: ‘r’, 3: ‘r’}
for i in pusat.keys():
plt.scatter(*pusat[i], color=colmap[i],
marker=’*’,s=50)
plt.xlim(0, 20)
plt.ylim(0, 20)
plt.show()
Tahap Penugasan
## Penugasan

def penugasan(df, pusat):

for i in pusat.keys():
# sqrt((x1 - x2)^2 - (y1 - y2)^2)
df[‘jarakdari_{}’.format(i)] = (
np.sqrt((df[‘x’] - pusat[i][0]) ** 2+ (df[‘y’]
- pusat[i][1]) ** 2))
pusat_jarak_cols = [‘jarakdari_{}’.format(i) for i
in pusat.keys()]
df[‘terdekat’] = df.loc[:, pusat_jarak_cols].
idxmin(axis=1)
df[‘terdekat’] = df[‘terdekat’].map(lambda x:
int(x.lstrip(‘jarakdari_’)))
df[‘warna’] = df[‘terdekat’].map(lambda x:
colmap[x])
return df
df = penugasan(df, pusat)
print(df.head())
fig = plt.figure
 Metode Klaster Berdasarkan Pusat 75

plt.scatter(df[‘x’], df[‘y’], color=df[‘warna’],

alpha=0.5, edgecolor=’k’)
for i in pusat.keys():
plt.scatter(*pusat[i], color=colmap[i])
plt.xlim(0, 20)
plt.ylim(0, 20)
plt.show()
Luaran
## Tahap memperbaharui

import copy
pusat_lama = copy.deepcopy(pusat)

def update(k):
for i in pusat.keys():
pusat[i][0] = np.mean(df[df[‘terdekat’] == i]
[‘x’])
pusat[i][1] = np.mean(df[df[‘terdekat’] == i]
[‘y’])
return k
pusat = update(pusat)
fig = plt.figure
ax = plt.axes()
plt.scatter(df[‘x’], df[‘y’], color=df[‘warna’],
alpha=0.5, edgecolor=’k’)
for i in pusat.keys():
plt.scatter(*pusat[i],
color=colmap[i],marker=’*’,s=50)
plt.xlim(0, 20)
plt.ylim(0, 20)
76 Machine Learning dengan Python

for i in pusat_lama.keys():
x_lama = pusat_lama[i][0]
y_lama = pusat_lama[i][1]
dx = (pusat[i][0] - pusat_lama[i][0]) * 0.75
dy = (pusat[i][1] - pusat_lama[i][1]) * 0.75
plt.show()

Mengulangi Tahap Penugasan

## Pengulangan penugasan
df = penugasan(df, pusat) # Plot results
fig = plt.figure
plt.scatter(df[‘x’], df[‘y’], color=df[‘warna’],
alpha=0.5, edgecolor=’k’)
for i in pusat.keys():
 Metode Klaster Berdasarkan Pusat 77

plt.scatter(*pusat[i],
color=colmap[i],marker=’*’,s=50)
plt.xlim(0, 20)
plt.ylim(0, 20)
plt.show()
Luaran

Terus dilanjutkan sampai tidak ada data yang berubah dan sudah terkelompokkan dengan
baik.
# Dilanjutkan hingga pusat tidak berubah
while True:
pusat_terdekat = df[‘terdekat’].copy(deep=True)
pusat = update(pusat)
df = penugasan(df, pusat)
if pusat_terdekat.equals(df[‘terdekat’]):
break

fig = plt.figure
78 Machine Learning dengan Python

plt.scatter(df[‘x’], df[‘y’], color=df[‘warna’],

alpha=0.5, edgecolor=’k’)
for i in pusat.keys():
plt.scatter(*pusat[i],
color=colmap[i],marker=’*’,s=50)
plt.xlim(0, 20)
plt.ylim(0, 20)
plt.show()

Maka telah dipunyai 2 klaster dengan 2 pusat (means) atau center di tiap klaster. Untuk satu
pusat di atas kanan tidak ada data di sekitarnya.

Contoh 2.5 Menggunakan scikitlearn

Diberikan data yang semula telah dibuat dan dihitung untuk latihan menghitung jarak sebagai
berikut:
Program Luaran
from pandas import DataFrame
list = {‘x’:[ 1, 4, 5, 8, 9, 12, 13, 16, 17, 20],’y’:[
2, 3, 6, 7, 10, 11, 14, 15, 18, 19]}
data = DataFrame(list,columns=[‘x’,’y’])
print (data) x y
 Metode Klaster Berdasarkan Pusat 79

0 1 2
1 4 3
2 5 6
3 8 7
4 9 10
5 12 11
6 13 14
7 16 15
8 17 18
9 20 19

# Contoh fungsi menghitung jarak Euclide

import numpy as np
def hitung_jarak(pusatK, X, Y):
Hasiljarak = []
# beri nama pusat klaster
c_x, c_y = pusatK

# Iterasi titik-titik data dan hitung jarak dengan

rumus jarak Euclid
for x, y in list(zip(X, Y)):
kuadrat_xminusc = (x - c_x) ** 2
kuadrat_yminusc = (y - c_y) ** 2
jarak = np.sqrt(kuadrat_xminusc + kuadrat_
yminusc)
Hasiljarak.append(jarak)
return Hasiljarak
Sebagaimana pada kegiatan sebelum ini, jika masing-masing pasang disebut sebagai
koordinat pada 2 dimensi sebagaimana pada gambar maka terlihat bahwa hampir semua
pasangan titik dalam 1 garis seperti pada gambar berikut.
80 Machine Learning dengan Python

Program

import numpy as np
import matplotlib.pyplot as plt
list = [[1,2],[4,3],[5, 6],[8, 7],[9, 10],[12,
11],[13,14],[16, 15],[17,18],[20, 19]]
x, y = zip(*list)
plt.plot(x,y, linestyle = ‘’,color=’darkblue’,marker =
‘*’,markersize=5,markeredgecolor=’darkblue’,
markerfacecolor=’purple’ )
plt.xlabel(“x”)
plt.ylabel(“y”)
plt.show()

Luaran

Sekilas kita dapat memperhatikan bahwa pasangan titik di atas dapat dipisahkan menjadi
2 klaster dengan menentukan pusat klaster, misalkan tanpa teknik matematika kita dapat
menemukan pusat klaster sekitar (5.4 5.6) dan (15.6 15.4) pada gambar di atas. Lalu dilakukan
percobaan untuk menentukan pemisahan menjadi 2 klaster dengan menu pada scikit-learn.
 Metode Klaster Berdasarkan Pusat 81

Program

from pandas import DataFrame

import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
data = DataFrame(list,columns=[‘x’,’y’])
print (data)
kmeans = KMeans(n_clusters=2).fit(data)
centroids = kmeans.cluster_centers_
print(centroids)
plt.plot(x,y, linestyle = ‘’,color=’darkblue’,marker =
‘*’,markersize=10,markeredgecolor=’darkblue’,
markerfacecolor=’purple’ )
plt.scatter(centroids[:, 0], centroids[:, 1],
c=’green’, s=90)
plt.xlabel(“x”)
plt.ylabel(“y”)
plt.show()

Luaran
x y
0 1 2
1 4 3
2 5 6
3 8 7
4 9 10
5 12 11
6 13 14
7 16 15
8 17 18
82 Machine Learning dengan Python

9 20 19
[[15.6 15.4]
[ 5.4 5.6]]

Dapat diketahui dengan gambar di atas manakah yang dalam klaster 1 dan yang
digolongkan klaster 2. Perhatikan bahwa data pasangan data di mana x sekitar 1-11 merupakan
1 klaster ke-1, dan data di mana x sekitar 12-20 pada klaster yang ke-2. Hasil pusat klaster
yang menggunakan Python diperoleh (5.4 5.6) pusat klaster ke-1 dan (15.6 15.4) pada klaster
ke-2.

2.3.2. Dengan Daftar Data dalam 4 Klaster

from pandas import DataFrame
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans

Data = {‘x’: [25,34,22,27,33,33,31,22,35,34,67,54,57,4

3,50,57,59,52,65,47,49,48,35,33,44,45,38,43,51,46],
‘y’: [79,51,53,78,59,74,73,57,69,75,51,32,40,4
7,53,36,35,58,59,50,25,20,14,12,20,5,29,27,8,7]
}
 Metode Klaster Berdasarkan Pusat 83

df = DataFrame(Data,columns=[‘x’,’y’])

kmeans = KMeans(n_clusters=4).fit(df)
centroids = kmeans.cluster_centers_
print(centroids)

plt.scatter(df[‘x’], df[‘y’], c= kmeans.labels_.

astype(float), s=50, alpha=0.5)
plt.scatter(centroids[:, 0], centroids[:, 1], c=’red’,
s=50

Luaran:
[[43.2 16.7 ]
[30.83333333 74.66666667]
[27.75 55. ]
[55.1 46.1 ]]
<matplotlib.collections.PathCollection at 0x39a6950>
84 Machine Learning dengan Python

2.3.3. K-means Clustering dengan Membangkitkan Data

File: Belajar K-Means2

Langkah 1. Membangkitkan data

#Web 3. https://blog.floydhub.com/introduction-to-k-
means-clustering-in-python-with-scikit-learn/
# Tujuan : K-means Clustering dengan data dibangkitkan

from sklearn.datasets.samples_generator import make_

blobs

# Membangkitkan data 2 dimensi

X, _ = make_blobs(n_samples=10, centers=3, n_
features=2,cluster_std=0.2, random_state=0)

# mengkonversikan data dalam pandas DataFrame

import pandas as pd

# membangun obyek data

obj_names = []
for i in range(1, 11):
obj = “Obyek” + str(i)
obj_names.append(obj)

Langkah 2.
# Menyusun pandas DataFrame dengan nama-nama serta
koordinat (x,y)
data = pd.DataFrame({
‘Obyek’: obj_names,
‘Nilai_X’: X[:, 0],
 Metode Klaster Berdasarkan Pusat 85

‘Nilai_Y’: X[:, -1]})

# Menampilkan data
print(data.head())
#Perlu gambar juga
data.plot(x =’Nilai_X’, y=’Nilai_Y’, kind =
‘scatter’)

Luaran
Obyek Nilai_X Nilai_Y
0 Obyek1 1.005079 4.594642
1 Obyek2 1.128478 4.328122
2 Obyek3 2.117881 0.726845
3 Obyek4 0.955626 4.385907
4 Obyek5 -1.354017 2.769449
86 Machine Learning dengan Python

Langkah 3.
#langkah awal: initialisasi pusat
#
c1 = (-1, 4)
c2 = (-0.2, 1.5)
c3 = (2, 2.5)

# Contoh fungsi menghitung jarak Euclide

import numpy as np
def hitung_jarak(pusatK, X, Y):
Hasiljarak = []
# beri nama pusat klaster
c_x, c_y = pusatK

# Iterasi titik-titik data dan hitung jarak dengan

rumus jarak Euclid
for x, y in list(zip(X, Y)):
kuadrat_xminusc = (x - c_x) ** 2
kuadrat_yminusc = (y - c_y) ** 2
jarak = np.sqrt(kuadrat_xminusc + kuadrat_
yminusc)
Hasiljarak.append(jarak)
return Hasiljarak
# Bandingkan, tempatkan, rata-rata dan ulangi
# Ini adalah bagian paling penting pada tahap akhir
K-means
# Jika jarak data dan pusatKlaster telah diperoleh
bandingkan jarak tersebut, pilih terkecil
# Pusat dimana jarak untuk suatu data terkecil, maka
 Metode Klaster Berdasarkan Pusat 87

pusat diambil dari data tersebut. Kemudian proses

diulang
#Hitung jarakdan tempatkan pada DataFrame yang sesuai
data[‘C1_Jarak’] = hitung_jarak(c1, data.Nilai_X,
data.Nilai_Y)
data[‘C2_Jarak’] = hitung_jarak(c2, data.Nilai_X,
data.Nilai_Y)
data[‘C3_Jarak’] = hitung_jarak(c3, data.Nilai_X,
data.Nilai_Y)

# Tampilkan data
print(data.head())

Luaran:
Obyek Nilai_X Nilai_Y C1_Jarak C2_Jarak
C3_Jarak
0 Obyek1 1.005079 4.594642 2.091397 3.320997
2.318921
1 Obyek2 1.128478 4.328122 2.153620 3.124601
2.025236
2 Obyek3 2.117881 0.726845 4.520479 2.443428
1.777070
3 Obyek4 0.955626 4.385907 1.993339 3.108686
2.155774
4 Obyek5 -1.354017 2.769449 1.280462 1.715592
3.364823

#Ambil jarak terkecil dari pusat

data[‘Klaster’] = data[[‘C1_Jarak’, ‘C2_Jarak’, ‘C3_
Jarak’]].apply(np.argmin, axis =1)
88 Machine Learning dengan Python

# Tunjuk sebagai pusat klaster baru

data[‘Klaster’] = data[‘Klaster’].map({‘C1_Jarak’:
‘C1’, ‘C2_Jarak’: ‘C2’, ‘C3_Jarak’: ‘C3’})

# Tampilkan data kembali

print(data.head(10))
# #Hasil di atas tidak ada C2

# Sekarang yang penting lagi adalah :

# mengupdate pusat-pusat klaster dengan mencari rata-
rata koordinat
#

# (Sigma xi/n, Sigma yi/n)

#Hitung koordinat pusat klaster ke-1 yang baru

x_pusat1_baru = data[data[‘Klaster’]==’C1’]
[‘Nilai_X’].mean()
y_pusat1_baru = data[data[‘Klaster’]==’C1’]
[‘Nilai_Y’].mean()

#Hitung koordinat pusat klaster ke-2 yang baru

x_pusat2_baru = data[data[‘Klaster’]==’C3’]
[‘Nilai_X’].mean()
y_pusat2_baru = data[data[‘Klaster’]==’C3’]
[‘Nilai_X’].mean()

# Tuliskan koordinat pusat yang baru

print(‘Pusat 1 ({}, {})’.format(x_pusat1_baru , y_
 Metode Klaster Berdasarkan Pusat 89

pusat1_baru))
print(‘Pusat 2 ({}, {})’.format(x_pusat2_baru, y_
pusat2_baru))

Luaran :
Pusat 1 (-0.500753347459331, 3.4851226841526897)
Pusat 2 (1.7821539902873855, 1.7821539902873855)

2.4. Variasi dari algoritma K-Means

2.4.1. Algoritma K-Means kontinu

Algoritma K-means kontinu dibentuk pada tahun 1994 untuk mempercepat algoritma K-means
di atas standar di mana perbedaannya dengan yang standar sebagai berikut:
1. Pada algoritma K-means kontinu, prototipe, atau titik-titik referensi dipilih sebagai sampel
random dari database, sedangkan pada K-means standar titik-titik awal pada algoritma
dipilih secara sembarang.
2. Titik-titik data diperlakukan berbeda. Selama setiap iterasi selesai, K-means kontinu
hanya menguji titik-titik sampel data, sedangkan K-means standar menguji semua data.
Secara teori, sampel acak mewakili konsep Macqueen dari algoritma pada ruang kontinu.
Pada formula Macqueen, ukuran error Ei pada daerah Ri diberikan oleh:

Ei   Ri
  x   x  zi 2 d x

Di mana ρ(·) adalah fungsi distribusi probabilitas, yang mana fungsi kontinu didefinisikan
pada ruang, dan zi sebagai pusat dari daerah Ri . Jumlah semua Ei adalah total ukuran error.
Sampel random dari data dapat dianggap dugaan yang bagus dari fungsi distribusi probabilitas
ρ(·). Sampel yang demikian memberikan himpunan pusat-pusat yang mewakili dan dugaan
yang baik dari ukuran error tanpa menggunakan titik-titik data dari data asli. Karena keduanya
memberikan titik-titik referensi dan titik-titik data untuk update dipilih oleh sampel acak,
algoritma K-means kontinu pada umumnya lebih cepat daripada yang standar.
90 Machine Learning dengan Python

2.4.2. Algoritma Pembandingan Rata-Rata

Untuk mempercepat algoritma K-means, terdapat pula algoritma pembanding rata-rata
dengan cara menghindari beberapa pembandingan yang tidak perlu, misalkan x adalah
titik pada D dan i dan  j adalah 2 rata-rata. Dengan pertidaksamaan segitiga diperoleh

    sehingga d  x,  j   d  i ,  j   d  x, i  . Oleh karena itu,

d  x, i   d x,  j  d i ,  j

diperoleh d  x,  j   d  x, i  jika d  i ,  j   2d  x, i  . Pada kasus ini, perhitungan d  x,  j 

menjadi tidak penting. Ingat, bahwa jarak terhadap pusat yang terkecil yang diperhatikan.
Karena K sebagai banyaknya klaster biasanya kecil, jarak semua pasangan rata-rata dihitung
sebelum setiap iterasi. Kemudian, sebelum membandingkan suatu titik x pada suatu rata-rata
 j , pengujian di atas menggunakan rata-rata yang diketahui terdekat dengan x. Hal inilah
ide dasar algoritma pembandingan rata-rata di mana algoritma ditulis secara lengkap pada
literatur (Gan et al., 2007).

2.4.3. Algoritma Pengurutan Rata-Rata

Algoritma pengurutan rata-rata (Sort-means algorithm) adalah perluasan algoritma
pembandingan rata-rata. Rata-rata diurutkan dengan jarak yang semakin membesar dari setiap
 
rata-rata untuk memperoleh percepatan lebih jauh. Ambil Dij  d i ,  j untuk i,j=1,2,...,k di
mana i adalah rata-rata pada klaster ke-i. Sebutlah M adalah matriks kxk di mana baris i
    
(mi1,mi2,...,mik) adalah permutasi dari 1,2,...,k sehingga d i , mi 1  d i , mi 2   d i , mik . 
2.4.4. Algoritma E-M
Algoritma E-M (Expectation-Maximization) merupakan algoritma yang dianggap mudah dan
dapat dimengerti. Metode ini dengan prosedur sebagai berikut:
1. Menebak beberapa pusat klaster.
2. Ulangi proses hingga konvergen di mana terdapat:
a. Tahap E: menugaskan titik-titik ke pusat klaster terdekat.
b. Tahap M: menetapkan pusat-pusat klaster sebagai rata-rata.
Tahap E menyatakan tahapan di mana titik-titik klaster diharapkan berada.
Tahap M menyatakan sebagai langkah memaksimumkan kecocokan fungsi yang
mendefinisikan lokasi dari pusat-pusat klaster. Akan tetapi, algoritma ini mempunyai
kelemahan, yaitu iterasinya tidak konvergen global, tetapi lokal.
 Metode Klaster Berdasarkan Pusat 91

2.5. Kelemahan Lain K-Means Clustering

Batas-batas klaster hampir selalu linear. Hal ini artinya untuk batas-batas yang kompleks,
K-means nyaris gagal. Untuk itu, diperkenalkan transformasi kernel (sebagaimana nantinya
pada Support Vector Machine), yaitu mentransformasikan data pada dimensi yang lebih tinggi
dengan pemisahan linear jika dimungkinkan. Pada scikit-learn Python, hal ini difasilitasi oleh
modul SpectralClustering yang menggunakan graf dari persekitaran terdekat untuk menghitung
representasi data pada dimensi yang lebih tinggi dan kemudian memberikan pelabelan dengan
algoritma K-means.

2.5.1. Menggunakan Python untuk Kasus Batas Data tidak Linear

Pada bagian ini, ditunjukkan bagaimana kasus batas data tidak linear.

Contoh 2.6
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
labels = KMeans(2, random_state=0).fit_predict(X)
plt.scatter(X[:, 0], X[:, 1], c=labels,s=50,
cmap=’viridis’);
#Clustering untuk bentuk batas kompleks
from sklearn.datasets import make_moons
X, y = make_moons(200, noise=.05, random_state=0)
from sklearn.cluster import SpectralClustering
model = SpectralClustering(n_clusters=2,
affinity=’nearest_neighbors’,assign_labels=’kmeans’)
labels = model.fit_predict(X)
plt.scatter(X[:, 0], X[:, 1], c=labels,s=50,
cmap=’viridis’);
92 Machine Learning dengan Python

Dengan kernel yang digunakan, K-Means berhasil melakukan pemisahan. Salah satu
kelemahan lain K-means adalah algoritma berjalan lambat untuk sampel yang banyak. Untuk
itu, dilakukan perbaikan dengan cara menggunakan sebagian data untuk memperbarui
pusat klaster tiap tahap iterasi. Hal inilah yang kemudian menjadi dasar untuk modul dalam
scikitlearn, yaitu sklearn.cluster.MiniBatchKMeans. Hal ini serupa dengan standar KMeans
yang selanjutnya akan dijelaskan perbedaannya.
MiniBatchKMeans adalah varian dari algoritma K-Means yang menggunakan mini-batch
untuk mengurangi waktu komputasi, sambil tetap berusaha untuk mengoptimalkan fungsi
tujuan yang sama. Mini-batch adalah himpunan bagian dari data input, yang diambil sampelnya
secara acak di setiap iterasi pelatihan. Mini-batch ini secara drastis mengurangi jumlah
perhitungan yang diperlukan untuk konvergen ke solusi lokal. Berbeda dengan algoritma lain
yang mengurangi waktu konvergensi K-means, K-means mini-batch menghasilkan hasil yang
umumnya hanya sedikit lebih buruk daripada algoritma standar. MiniBatchKMeans melakukan
konvergensi lebih cepat daripada KMeans, tetapi kualitas hasilnya berkurang. Dalam praktiknya,
perbedaan kualitas ini bisa sangat kecil. Algoritma ini beralih di antara dua langkah utama, mirip
dengan vanilla K-means. Pada langkah pertama, sampel b diambil secara acak dari dataset
untuk membentuk mini-batch. Ini kemudian ditugaskan ke centroid terdekat. Pada langkah
kedua, centroid diperbarui. Berbeda dengan K-means, ini dilakukan berdasarkan per sampel.
Untuk setiap sampel dalam mini-batch, centroid yang ditugaskan diperbarui dengan mengambil
rata-rata streaming dari sampel dan semua sampel sebelumnya yang ditugaskan ke centroid
tersebut. Ini memiliki efek penurunan tingkat perubahan untuk centroid dari waktu ke waktu.
Langkah-langkah ini dilakukan sampai konvergensi atau jumlah iterasi yang telah ditentukan
tercapai. Salah satu aplikasi yang menunjukkan kecepatan Mini Batch K-means adalah
dengan adanya pengelompokan cepat untuk data sel tunggal Cell RNA-Sequencing (scRNA-
seq), yaitu suatu teknologi tinggi yang paling banyak digunakan untuk mengukur ekspresi gen
 Metode Klaster Berdasarkan Pusat 93

lebar genom pada tingkat sel tunggal. Salah satu analisis data scRNA-seq yang paling umum
mendeteksi subpopulasi sel yang berbeda melalui penggunaan algoritma pengelompokan
unsupervised-learning. Namun, kemajuan terbaru dalam teknologi scRNA-seq menghasilkan
kumpulan data saat ini mulai dari ribuan hingga jutaan sel. Algoritma pengelompokan yang
populer, seperti K-means, biasanya membutuhkan data untuk dimuat seluruhnya ke dalam
memori dan karenanya bisa lambat atau tidak mungkin dijalankan dengan dataset besar,
sedangkan Mini Batch K-means dapat bekerja lebih baik (Hicks et al., 2021)recent advances in
scRNA-seq technologies result in current datasets ranging from thousands to millions of cells.
Popular clustering algorithms, such as k-means, typically require the data to be loaded entirely
into memory and therefore can be slow or impossible to run with large datasets. To address this
problem, we developed the mbkmeans R/Bioconductor package, an open-source implementation
of the mini-batch k-means algorithm. Our package allows for on-disk data representations,
such as the common HDF5 file format widely used for single-cell data, that do not require
all the data to be loaded into memory at one time. We demonstrate the performance of the
mbkmeans package using large datasets, including one with 1.3 million cells. We also highlight
and compare the computing performance of mbkmeans against the standard implementation
of k-means and other popular single-cell clustering methods. Our software package is available
in Bioconductor at https://bioconductor.org/packages/ mbkmeans.”,”author”:[{“dropping-pa
rticle”:””,”family”:”Hicks”,”given”:”Stephanie C.”,”non-dropping-particle”:””,”parse-names”:fa
lse,”suffix”:””},{“dropping-particle”:””,”family”:”Liu”,”given”:”Ruoxi”,”non-dropping-particle”:””-
,”parse-names”:false,”suffix”:””},{“dropping-particle”:””,”family”:”Ni”,”given”:”Yuwei”,”non-
dropping-particle”:””,”parse-names”:false,”suffix”:””},{“dropping-particle”:””,”family”:”Purdom
”,”given”:”Elizabeth”,”non-dropping-particle”:””,”parse-names”:false,”suffix”:””},{“dropping-
particle”:””,”family”:”Risso”,”given”:”Davide”,”non-dropping-particle”:””,”parse-names”:false,”suf
fix”:””}],”container-title”:”PLoS Computational Biology”,”id”:”ITEM-1”,”issue”:”1”,”issued”:{“date-
parts”:[[“2021”]]},”page”:”1-18”,”title”:”Mbkmeans: Fast clustering for single cell data using
mini-batch k-means”,”type”:”article-journal”,”volume”:”17”},”uris”:[“http://www.mendeley.com/
documents/?uuid=f9a67b19-1188-44fd-82f6-2cf798422567”]}],”mendeley”:{“formattedCitation
”:”(Hicks et al., 2021.
94 Machine Learning dengan Python

DAFTAR PUSTAKA
Dabbura, I. 2018. K-means Clustering: Algorithm, Applications, Evaluation Methods, and
Drawbacks. https://towardsdatascience.com/k-means-clustering-algorithm-applications-
evaluation-methods-and-drawbacks-aa03e644b48a.
Gan, G., Ma, C., & Wu, J. 2007. Data Clustering. American Statistical Association and SIAM
Philadelpia.
Hicks, S. C., Liu, R., Ni, Y., Purdom, E., & Risso, D. 2021. Mbkmeans: Fast Clustering for
Single Cell Data using Mini-Batch K-means. PLoS Computational Biology, 17(1), 1–18.
https://doi.org/10.1371/JOURNAL.PCBI.1008625.
Kobylin, O., & Lyashenko, V. 2020. Time Series Clustering Based on the K-Means Algorithm.
Journal La Multiapp, 1(3), 1–7. https://doi.org/10.37899/journallamultiapp.v1i3.191.
Li, Y., & Wu, H. 2012. A Clustering Method Based on K-Means Algorithm. Physics Procedia, 25,
1104–1109. https://doi.org/10.1016/j.phpro.2012.03.206.
Virgantari, F., & Faridhan, Y. E. 2020. K-Means Clustering of Covid-19 Cases in Indonesia’s
Provinces. ADRI International Journal of Engineering and Natural Science, 5(2), 1–7.
BAB 3
NATURAL LANGUAGE PROCESS
(NLP): MACHINE LEARNING
UNTUK DATA TEKS

Manusia berkomunikasi melalui beberapa bentuk bahasa, baik dengan teks atau ucapan.
Untuk melakukan interaksi antara komputer dan manusia, komputer perlu memahami
bahasa alami yang digunakan oleh manusia. Oleh karena itu, dibuatlah bahasa yang disebut
Pemrosesan Bahasa Alami atau Natural Language Process (NLP) yang membahas tentang
membuat komputer belajar, memproses, dan memanipulasi bahasa alami. NLP adalah cabang
kecerdasan buatan yang berurusan dengan analisis, pemahaman, dan menghasilkan bahasa
yang digunakan manusia secara alami untuk berinteraksi dengan komputer dalam konteks
tertulis dan lisan menggunakan bahasa alami manusia, bukan bahasa komputer.

3.1. Prinsip Kerja NLP

Sudah siapkah Anda belajar lebih jauh? Mari kita lanjutkan pelajaran kita. Secara umum, suatu
proses penelitian NLP akan mengikuti siklus yang ditunjukkan pada Gambar 3.1. Siklus kerja
pada NLP yang ditunjukkan pada Gambar 3.1 dijelaskan berikut ini.
1. Pemahaman terhadap konteks masalah yang sedang dihadapi. Tugas apa yang akan
dilakukan untuk menjawab masalah tersebut, apakah tokenisasi, klasifikasi, atau yang
lainnya.
2. Setelah mampu memahami konteks masalah dan tugas yang akan dikerjakan, selanjutnya
pikirkan tentang jenis data atau corpus yang Anda butuhkan untuk memecahkan masalah.
Di sini, pengumpulan data adalah kegiatan dasar dalam penelitian Anda. Sering kali bagian
96 Machine Learning dengan Python

ini pun akan memakan waktu yang cukup lama karena mengumpulkan data bukanlah hal
yang mudah.
3. Setelah berhasil mengumpulkan cukup data, Anda dapat mulai menganalisis data
tersebut. Bagaimana kualitas dan kuantitas corpus yang dikumpulkan? Apakah sesuai
dengan kualitas yang diharapkan? Di sini, eksplorasi dan visualisasi awal dari data
menjadi penting. Anda pun akan perlu untuk melakukan pra-pemrosesan data.

Memahami masalah

Kumpulkan dataset/corpus

Analisis dataset/corpus

Preprocessing dataset

Menentukan fitur-fitur

Menentukan fitur-fitur

Tetapkan teknik komputasi yang digunakan

MI, Aturan yang digunakan, dst

Tes dan evaluasi hasil

Cermati parameter untuk optimasi

Lanjutkan hingga diperoleh hasil yang memuaskan

Gambar 3.1 Prinsip kerja NLP

(Sumber: Beysolow II, 2018)
 Natural Language Process (NLP): Machine Learning untuk Data Teks 97

4. Setelah selesai membersihkan dan merapikan data pada tahap pra-pemrosesan,

selanjutnya Anda harus mulai dengan proses pemilihan fitur data. Rekayasa fitur adalah
aspek terpenting dari NLP karena fitur yang buruk akan memengaruhi proses pelatihan
model yang Anda gunakan.
5. Langkah selanjutnya, setelah Anda berhasil mengekstrak fitur dari data yang dimiliki adalah
memutuskan algoritma atau model apakah yang akan digunakan untuk memecahkan
masalah Anda. Apakah perlu menggunakan sebuah arsitek deep learning atau sudah
cukup dengan menggunakan algoritma Machine Learning. Model yang Anda pilih akan
turut menentukan keberhasilan penelitian Anda.
6. Proses pelatihan model dilakukan dengan menggunakan data yang telah dibersihkan
dan dipilih fiturnya. Perlu diperhatikan bahwa sebelum melakukan proses pelatihan,
terlebih dahulu Anda perlu membagi data yang Anda miliki menjadi data latih dan data tes.
Jangan melakukan uji performa algoritma/model Anda menggunakan data yang sama
yang digunakan dalam proses pelatihan. Hal ini bertujuan agar Anda dapat mengetahui
seberapa baik algoritma/model yang Anda gunakan dalam menganalisis data baru yang
belum pernah dianalisis sebelumnya.
7. Setelah proses pelatihan selesai, Anda dapat menyelidiki seberapa baik proses pelatihan
yang dilakukan dengan melakukan uji algoritma/model menggunakan data uji yang
sebelumnya telah dipisahkan. Lakukan pengujian algoritma dan jangan lupa untuk
melakukan evaluasi terhadap output dari prosedur pengujian algoritma/model Anda.
Beberapa ukuran atau metrik yang dapat digunakan untuk mengevaluasi hasil uji model
akan dijelaskan pada bab selanjutnya di dalam buku ini.
8. Berdasarkan hasil evaluasi pengujian algoritma/model yang telah Anda lakukan pada
tahap 7, Anda dapat menyesuaikan beberapa parameter algoritma/model Anda untuk
mendapat hasil yang optimal. Proses ini bisa Anda lanjutkan hingga didapatkan hasil
yang memuaskan.
Sekilas, tahapan-tahapan yang dijelaskan secara singkat di atas tampak mudah. Namun,
pada kenyataannya, satu atau lebih tahapan dapat menjadi sangat sulit dan membingungkan,
mengingat hubungan antara kata dalam kalimat dalam sebuah corpus adalah non-linear
sehingga bisa menjadi sangat sulit dan kompleks. Hal ini turut bergantung pada jenis data teks
yang Anda tangani. Di samping itu, harus selalu diingat bahwa pengalaman adalah guru yang
baik. Dengan sering menghadapi dan mengatasi masalah-masalah dalam penelitian NLP,
Anda menjadi semakin mahir dalam membangun dan melatih suatu model yang baik. Selamat
berlatih.
98 Machine Learning dengan Python

3.1.1. Library Penting yang Digunakan dalam Pemrosesan Bahasa pada

Python
Bahasa pemrograman Python untuk pertama kalinya dirilis di Belanda oleh Guido van Rossum
pada tahun 1991 (Severance, 2015). Mengejutkan bukan, bahasa pemrograman yang seperti
sedang viral di hari-hari belakangan ini ternyata telah mencapai usia yang tidak muda lagi.
Perkembangannya yang pesat belakangan ini didorong oleh beberapa aspek, di antaranya
tingkat keterbacaan yang cukup tinggi (mudah dimengerti), efisien dalam pengetikan dan
waktu, serta multifungsi di mana Anda dapat mengerjakan banyak hal dengan Python, mulai
dari pemrograman aplikasi, web, maupun Android (Fadlilah et al., 2021)but there are 2 kinds of
sign languages (SIBI and BISINDO . Selain itu, Python juga dapat dengan mudah berinteraksi
dengan bahasa pemrograman yang lain (kode-kode bahasa pemrograman lain dapat dipanggil
dan dijalankan menggunakan bahasa Python). Mengingat Python bersifat open source, tentu
saja menyebabkan banyak pengguna memilih Python. Hal ini juga tentunya mendongkrak
jumlah komunitas berbagi di berbagai daerah, terutama komunitas virtual di berbagai jejaring
sosial media (Thivaharan et al., 2020).

Gambar 3.2 Contoh komunitas Python di Telegram

 Natural Language Process (NLP): Machine Learning untuk Data Teks 99

Kami berharap Anda sudah memiliki program Python yang terinstal di komputer ketika
membaca buku ini. Jika belum, mungkin ini saatnya mencari komunitas bertumbuh yang
cocok untuk mendorong perkembangan skill Anda. Sama halnya dengan berbagai bahasa
pemrograman yang lain, Python juga bekerja dengan menggunakan berbagai modul
atau biasanya dikenal dengan istilah library. Library pada umumnya dapat dimiliki dengan
melakukan pip-installation (pip install) dari anaconda-prompt. Beberapa library dasar yang
sebaiknya Anda miliki, misalnya Jupyterlab, Pandas, Numpy, Scipy, Matplotlib.pyplot, Seaborn,
Sklearn, Tkinter, NLTK, dan Sastrawi (khusus bagi mereka yang hendak menekuni NLP Bahasa
Indonesia). Fungsi dan kegunaan dari masing-masing library tentunya akan dipelajari seiring
Anda melangkah maju ke bagian-bagian selanjutnya.
Python memiliki banyak sekali library yang tersedia untuk mengekstraksi konten digital
yang tersebar di internet. Di antara library yang tersedia, tiga library berikut digunakan secara
populer untuk tujuan tersebut, yaitu BeautifulSoup, LXml, dan RegEx. Sebuah studi statistik
yang dilakukan pada kumpulan data yang tersebar menunjukkan bahwa RegEx mampu
memberikan jawaban rata-rata 153,7 ms. Namun, RegEx memiliki kelemahan yang melekat
pada ekstraksi aturan terbatas ketika datang ke halaman web dengan lebih banyak tag
dalam. Karena kekurangan ini, RegEx disebut hanya mampu melakukan konteks yang cukup
kompleks. Namun, BeautifulSoup dan LXml mampu mengekstraksi konten web di bawah
lingkungan demikian, serta menghasilkan tingkat respons masing-masing 458,68 ms dan
202,96 ms.

3.1.2. Corpus dan Data Teks

Dalam penelitian NLP, corpus (bahasa Latin: tubuh) mengacu pada kumpulan teks. Kumpulan
tersebut dapat dibentuk dari berbagai teks dengan satu bahasa yang sama atau dapat juga
menjangkau banyak bahasa. Corpora juga dapat terdiri dari kumpulan teks-teks dengan
tema tertentu, misalnya sejarah, Alkitab, dan lain-lain. Corpus atau Corpora umumnya hanya
digunakan untuk analisis linguistik statistik dan pengujian hipotesis. Secara praktis, corpus
dapat diartikan sebagai kumpulan data yang digunakan untuk mengembangkan aplikasi NLP.
Corpus tersebut dapat ditulis atau diucapkan secara alami dalam bahasa tertentu. Beberapa
corpus tersedia secara gratis dan dapat diakses dengan mudah di internet, corpus lainnya
perlu dikumpulkan secara manual dari berbagai sumber teks maupun rekaman suara.
100 Machine Learning dengan Python

Gambar 3.3 Corpus Othelo

Ada banyak alasan menggunakan corpus untuk mengembangkan aplikasi NLP, beberapa
di antaranya:
1. Dengan bantuan corpus, beberapa analisis statistik dapat dilakukan, misalnya frekuensi
distribusi, kejadian kemunculan bersama beberapa kata, dan sebagainya (Lane et al.,
2019).
2. Dengan corpus, berbagai aturan linguistik untuk sebuah aplikasi NLP dapat didefinisikan
maupun divalidasi. Misalnya, jika Anda membangun sistem koreksi tata bahasa, Anda
dapat menggunakan korpus teks dan mencoba mencari tahu contoh tata bahasa yang
salah, dan kemudian dapat menentukan aturan tata bahasa yang diinginkan.
Dalam corpus, kumpulan besar data dapat disimpan dalam format teks (naskah tertulis),
artinya bahan tertulis maupun data ucapan, materi yang diucapkan (rekaman suara). Data
dengan teks adalah kumpulan informasi tertulis yang biasanya bersumber dari artikel berita,
buku, perpustakaan digital, pesan e-mail, web halaman atau blog, sosial media, seperti Twitter,
Facebook, dan Instagram, maupun sumber lainnya, seperti yang tersedia pada beberapa modul
pemrograman Python. Sebagian besar data teks ini tersimpan dalam format txt. Walaupun ada
juga corpus yang tersimpan dalam format lainnya, misalnya json. Di bab ini, kita akan sama-
sama berlatih mengakses dan memanggil data teks pada Python. Silakan men-download
corpus Othello pada link berikut https://github.com/hannaariniparhusip/Indo_MachineLearning
di mana terdapat file Othelo.txt.
 Natural Language Process (NLP): Machine Learning untuk Data Teks 101

Selanjutnya, Anda perlu mengecek direktori penyimpanan hasil download corpus. Dalam
bahasa pemrograman Python, data text ekstensi ini dapat dipanggil dengan sangat mudah
mengikuti tahapan di bawah ini:
1. Bukalah anaconda prompt pada PC Anda.
2. Selanjutnya Anda dapat membuka jendela editor jupyter notebook pada lokasi direktori
yang diinginkan. Sebagai contoh, kode di bawah ini digunakan untuk membuka jendela
editor jupyter notebook pada drive D: di dalam folder dengan nama Latihan.

Gambar 3.4 Memanggil Jupyter Notebook

3. Jika pada jendela anaconda prompt muncul tampilan yang sama seperti pada Gambar
3.5, ini berarti instalasi berhasil dan selanjutnya hanya perlu menunggu jendela editor
jupyter notebook terbuka pada browser. Jika jendela editor tidak juga muncul, Anda dapat
mengopi salah satu link dari URLs yang muncul pada jendela anaconda prompt, paste di
browser dan tekan Enter.

Gambar 3.5 Tampilan Homepage Jupyter

102 Machine Learning dengan Python

4. Pada browser akan muncul jendela, seperti yang tampak pada Gambar 3.6 maka
selanjutnya Anda dapat membuat file notebook baru (biasanya dengan format .ipynb)
dengan cara memilih tombol New kemudian klik pada pilihan Python 3.

Gambar 3.6 Tampilan Homepage Jupyter

 Natural Language Process (NLP): Machine Learning untuk Data Teks 103

Gambar 3.7 Proses awal membuka Jupyter Notebook

5. Anda dapat terlebih dahulu mengubah nama dari file notebook Anda seperti yang tampak
pada Gambar 3.7.
6. Sekarang kita akan mulai memanggil data corpus yang sebelumnya telah kita download.
Proses pembacaan data teks dimulai dengan memanggil file dari direktori penyimpanannya.

alamat=r’C:\Users\DELL\Documents\Othello.txt’
with open(alamat,’r’,encoding=”utf8”) as f:
corpus=f.read()
f.close()

7. Dari Gambar 3.8 dapat dilihat tampilan teks di dalam corpus Othello.txt yang berhasil
dipanggil. Di sini tampak karakter ‘\n’ pada file teks yang ditampilkan. Karakter ini
merupakan tempat bagi spasi dalam file teks. Ini menunjukkan bahwa corpus yang
berhasil dipanggil masih memerlukan banyak pengolahan lainnya sebelum siap untuk
digunakan dalam pelatihan algoritma model yang diinginkan.
8. Selanjutnya, teks corpus keseluruhan ini akan dipenggal ke dalam beberapa bagian
menggunakan perintah

corpus_pisah=corpus.split(‘\n’)

Perintah corpus.split(‘\n’) akan membagi/memenggal teks pada korpus kita

berdasarkan karakter ‘\n’ yang muncul. Hasil pemenggalan/pemisahan (split) dapat
dilihat pada Gambar 3.9.
104 Machine Learning dengan Python

Gambar 3.8 Tampilan teks di dalam Corpus Othello.txt yang berhasil dipanggil

Gambar 3.9 Hasil penelusuran Corpus

(Sumber: Dokumentasi pribadi)

9. Jika Anda tidak nyaman dengan kehadiran banyak string kosong (‘’) dalam corpus, Anda
tentu dapat membersihkannya.

corpus_oke=[i for i in corpus if len(i) != 0]

Perintah di atas akan menciptakan sebuah list bagi Anda dengan nama corpus_oke,
kemudian setiap anggota corpus yang ukuran (panjang) stringnya tidak sama dengan nol
akan ditambahkan ke dalam list baru corpus_oke.
 Natural Language Process (NLP): Machine Learning untuk Data Teks 105

Gambar 3.10 Hasil penelusuran Corpus

(Sumber: Dokumentasi pribadi)

Corpus yang lebih rapi dapat dilihat pada Gambar 3.10. Langkah selanjutnya akan
dilakukan pra-pemrosesan yang bertujuan untuk menyiapkan data corpus Anda untuk
digunakan dalam proses pelatihan algoritma/model, baik Machine Learning maupun deep
learning.

3.2. Klasifikasi Teks dengan Algoritma NLP

Klasifikasi Teks adalah proses otomatis klasifikasi teks ke dalam kategori yang telah ditentukan,
misalkan klasifikasi berita sebagai berita politik, olah raga, kesenian, serta klasifikasi e-mail
sebagai kelompok spam dan non-spam. Algoritma yang digunakan adalah algoritma NLP
(Natural Language Process), yaitu cabang dari kecerdasan buatan yang difokuskan untuk
memungkinkan komputer memahami dan menafsirkan bahasa manusia (Dönmez, 2013)
(Hinton, 2020). Proses NLP didasarkan tahapan berikut ini.

Tahap 0. Input data

Pada tahap ini, data diinput dengan menyesuaikan sistem yang diacu. Demikian pula, terdapat
langkah pembangkitan bilangan random agar hasil yang diperoleh konsisten. Pada ML, hal ini
disediakan menu yang disebut random seed.

Tahap 1. Pre-proses data

Pada langkah ini, kita mentransformasi data mentah menjadi format yang dikenali untuk model
NLP Data biasanya tidak lengkap, tidak konsisten dan/atau juga kekurangan sesuatu atau
trend dan juga memuat error.
106 Machine Learning dengan Python

Langkah Tokenisasi
Langkah Tokenisasi (Tokenization), yaitu proses memenggal kata/teks menjadi kata, frasa
ataupun elemen bermakna yang disebut token. Daftar token kemudian digunakan sebagai
proses lebih lanjut. Pada library nltk mempunyai word_tokenize dan sent_tokenize yang
memudahkan daftar kalimat untuk dipenggal menjadi kata atau kalimat-kalimat. Ada beberapa
library di Python yang dapat digunakan untuk menyelesaikan tugas ini. Salah satu library yang
paling sering digunakan ialah NLTK dengan nltk.tokenize. Tokenizer akan membantu Anda
untuk membagi sebuah string menjadi beberapa substring. Adapun cara untuk menggunakan
berbagai metode pada library NLTK antara lain:

import nltk
nltk.download(‘punkt’)
from nltk.tokenize import word_tokenize
token_kata=word_tokenize(corpus_oke)

Sebelum menggunakan tokenizer, terlebih dahulu perlu dilakukan instalasi Punkt,

seperti yang tampak pada baris kode di atas nltk.download(‘punkt’). Di samping word
tokenizer, NLTK juga menyediakan tokenizer yang prinsip kerjanya didasari pada konsep
regular expression yang dapat membagi teks pada spasi dan tanda baca/karakter.
 Natural Language Process (NLP): Machine Learning untuk Data Teks 107

from nltk.tokenize import wordpunct_tokenize

token_regex=[wordpunct_tokenize(i) for i in corpus_
oke]
Agar lebih mudah dipahami perbedaan di antara kedua tokenizer ini, diberikan contoh
pada Gambar 3.11.

Gambar 3.11 Hasil contoh Corpus

(Sumber: Dokumentasi pribadi)

Dapat dilihat pada di atas, word_tokenize tidak mampu memisahkan ‘nasi+tempe’ dan
membacanya sebagai satu kesatuan saja, sedangkan di sisi lain dengan menggunakan
wordpunct_tokenize token yang dihasilkan juga sensitif terhadap tanda baca sehingga hasil
dari wordpunct_tokenize mampu memisahkan ‘nasi+tempe’ mejadi ‘nasi’, ‘+’ dan ‘tempe’.

Perhatian!
Saat membuat tokenisasi string Unicode, pastikan Anda tidak menggunakan versi string yang
disandikan (mungkin perlu didekodekan terlebih dahulu, misalnya dengan s.decode(“utf8”).

3.2.1. Konversi Huruf Kecil

Konversi huruf kecil di sini, yaitu mengubah semua huruf besar menjadi kecil. Hal ini diperlukan
karena Python adalah bahasa yang sifatnya case sensitive, yaitu membedakan dua huruf
kapital dan huruf kecilnya.
108 Machine Learning dengan Python

Gambar 3.12 Hasil konversi huruf kecil

(Sumber: Dokumentasi pribadi)

Seperti yang dapat dilihat di atas, huruf A kapital dan huruf a kecil dianggap oleh Python
sebagai dua objek yang berbeda. Perintah untuk melakukan perubahan huruf kecil pada
sebuah string adalah:

corpus_oke_kecil=[i.lower() for i in corpus_oke]

Pada Gambar 3.13 menunjukkan bahwa seluruh teks di dalam corpus tercetak dalam
huruf kecil.

Gambar 3.13 Hasil konversi huruf kecil untuk teks

(Sumber: Dokumentasi pribadi)
 Natural Language Process (NLP): Machine Learning untuk Data Teks 109

Langkah Lemmatisasi
Langkah Lemmatisasi (Word Stemming/Lemmatization) bertujuan sama dengan proses di
atas, yaitu mereduksi bentuk-bentuk infleksi dari tiap kata menjadi bentuk dasar atau akar
kata, misalkan kata eating menjadi eat. Lemmatization hampir dekat dengan stemming,
perbedaannya adalah bahwa stemmer mengoperasikan suatu kata tanpa ada pengetahuan
tentang konteks dan oleh karena itu tidak dapat membedakan kata yang mempunyai perbedaan
arti (misal roti dimakan dengan dimakan roti jelas berbeda, tetapi di sini tidak dibedakan).
Stemmer biasanya lebih mudah diimplementasikan dan lebih cepat dan penurunan akurasi
dapat menjadi tidak penting untuk beberapa aplikasi. Berikut ini adalah langkah lengkap yang
menyusun tahapan pre-processing:
1. Membuang baris yang blank dari data jika ada.
2. Mengubah semua huruf dalam huruf kecil.
3. Men-token kata.
4. Membuang stop word.
5. Membuang text non-alpha.
6. Meng-lemma kata.

Tahap 2. Menyiapkan data latih dan data uji

Sebagaimana pada langkah Machine Learning maka kita perlu memisahkan data menjadi data
latih dan data uji. Pada bagian ini akan ditunjukkan beberapa contoh penggunaannya.

Tahap 3. Encoding
Dengan encoding berarti memberikan pelabelan pada variabel target. Hal ini dilakukan dengan
mentransformasikan data kategori bertipe pada tipe string dalam data menjadi data bernilai
numerik.

Tahap 4. Vektorisasi Word

Langkah ini merupakan proses umum yang mengubah koleksi dokumen teks menjadi vektor-
vektor fitur. Terdapat banyak metode untuk itu, tetapi yang popular disebut TF-IDF (Term
Frequency — Inverse Document Frequency) yang memberikan skor/nilai pada tiap kata.
1. Term Frequency: Ini meringkas seberapa sering suatu kata muncul dalam dokumen.
2. Inverse Document Frequency: Ini memberikan penskalaan (secara menurun) terhadap
kata yang muncul dalam dokumen.
110 Machine Learning dengan Python

Tanpa detail matematika, TF-IDF adalah nilai frekuensi kata (word) yang diupayakan
menonjolkan lebih menarik, misal muncul sangat sering dokumen, tetapi tidak pada seluruh
dokumen. TF-IDF membangun koleksi kata yang telah dipelajari dari data corpus dan yang
menunjuk bilangan bulat secara tunggal kepada kata-kata ini. Terdapat 5000 kata/fitur
yang tunggal yang ditunjukkan pada parameter max_features=5000. Akhirnya, kita akan
mentransformasi Train_X dan Test_X yang divektorisasi Train_X_Tfidf dan Test_X_Tfidf.
Kemudian kita dapat menggunakan algoritma ML untuk memprediksi luaran, misal dengan
menggunakan Naïve Bayes sebagaimana ditunjukkan pada bagian selanjutnya.

3.2.2. Klasifikasi Teks dari Amazon Review

Pada sub-subbab ini akan ditunjukkan bagaimana klasifikasi data dari internet (https://arxiv.
org/abs/1410.5329) dari Amazon Review Data set. Data review ini pernah dilakukan analisis
sentimen yang tergolong menjadi 3, yaitu positif, negaitf, netral (Ravi et al., 2019), yang
mempunyai 10000 baris teks dan dikelompokkan menjadi Label 1 dan Label 2. Data memuat 2
kolom, yaitu kolom Text dan kolom Label.

Program dengan Python (dijalankan dalam Colab)

from google.colab import drive

drive.mount(“/content/drive”)

Tahap 1. memanggil Library yang digunakan

import pandas as pd
import numpy as np
from nltk.tokenize import word_tokenize
from nltk import pos_tag
from nltk.corpus import stopwords
from nltk.stem import WordNetLemmatizer
from sklearn.preprocessing import LabelEncoder
from collections import defaultdict
from nltk.corpus import wordnet as wn
from sklearn.feature_extraction.text import
TfidfVectorizer
 Natural Language Process (NLP): Machine Learning untuk Data Teks 111

from sklearn import model_selection, naive_bayes, svm

from sklearn.metrics import accuracy_score

Tahap 2. Membangkitkan random sedemikian hingga setiap luaran nantinya memberikan hasil
yang konsisten

np.random.seed(500)

Tahap 3. menambahkan Corpus

#Corpus = pd.read_csv(r”corpus.
csv”,encoding=’latin-1’)
Corpus = pd.read_csv(“/content/drive/My Drive/Colab
Notebooks/corpus.csv”,encoding=’latin-1’)
Corpus.columns

Tahap 4. Pre-proses: mentransformasi data , tokenisasi, word

“””\begin{table}[]
\begin{tabular}{lllll}
Form & Stem & Lemma \\
Studies & Studi & Study \\
Studying& Study & Study \\
beautiful &beauti & beautiful
\end{tabular}
\end{table}
# Tahap a : menghapus baris
Corpus[‘text’].dropna(inplace=True)
#Tahap b : Gantikan semua text dalam huruf kecil : hal
ini diperlukandalam python untuk membedakan antara
‘dog’ dan ‘DOG’”””
Corpus[‘text’] = [entry.lower() for entry in
Corpus[‘text’]]
“””Tahap :c: Tokenization : setiap antriancorpus akan
dipenggal tiap kata (word)”””
112 Machine Learning dengan Python

import nltk
nltk.download(‘punkt’)
Luaran:
[nltk_data] Downloading package punkt to /root/nltk_
data...
[nltk_data] Unzipping tokenizers/punkt.zip.
True

Corpus[‘text’]= [word_tokenize(entry) for entry in

Corpus[‘text’]] # jalan setelah import nltk dan
download punkt
nltk.download(‘wordnet’)
Luaran:
[nltk_data] Downloading package wordnet to /root/nltk_
data...
[nltk_data] Unzipping corpora/wordnet.zip.
True

#Hapus stop words, dan bentuk tak numberik maupun

susun lah word steeming/Lemmantion
# WordNetLemmatizer requires Pos tags to understand if
the word is noun or verb or adjective etc. By default
it is set to Noun
tag_map = defaultdict(lambda : wn.NOUN)
tag_map[‘J’] = wn.ADJ
tag_map[‘V’] = wn.VERB
tag_map[‘R’] = wn.ADV

nltk.download(‘averaged_perceptron_tagger’)
Luaran:
 Natural Language Process (NLP): Machine Learning untuk Data Teks 113

[nltk_data] Downloading package averaged_perceptron_

tagger to
[nltk_data] /root/nltk_data...
[nltk_data] Unzipping taggers/averaged_perceptron_
tagger.zip.
True

nltk.download(‘stopwords’)
[nltk_data] Downloading package stopwords to /root/
nltk_data...
[nltk_data] Unzipping corpora/stopwords.zip.
True

for index,entry in enumerate(Corpus[‹text’]):

#Mendeklarasi list kosong untuk pesan tempat
Final_words = []
# Menginisialisasi WordNetLemmatizer()
word_Lemmatized = WordNetLemmatizer()
# fungsi pos_
tag akan menyediakan ‹tag’ : jika kata benda
(N) atau kata kerja (V)
for word, tag in pos_tag(entry):
# Kondisi dibawah untuk menguji stop words dan
alfabet yang lain
if word not in stopwords.
words(‘english’) and word.isalpha():
word_Final = word_Lemmatized.lemmatize
(word,tag_map[tag[0]])
Final_words.append(word_Final)
#Proses final tehadap kata-
kata tiap iterasi yang disimpan pada ‘text_final’
Corpus.loc[index,’text_final’] = str(Final_words)
114 Machine Learning dengan Python

print(Corpus[‘text_final’].head())
Luaran:
0 [‘stun’, ‘even’, ‘sound’, ‘track’, ‘beautiful’...
1 [‘best’, ‘soundtrack’, ‘ever’, ‘anything’, ‘re...
2 [‘amaze’, ‘soundtrack’, ‘favorite’, ‘music’, ‘...
3 [‘excellent’, ‘soundtrack’, ‘truly’, ‘like’, ‘...
4 [‘remember’, ‘pull’, ‘jaw’, ‘floor’, ‘hear’, ‘...
Name: text_final, dtype: object

Tahap 2. pisahkan data menjadi data training dan data uji

Train_X, Test_X, Train_Y, Test_Y = model_

selection.train_test_split(Corpus[‘text_
final’],Corpus[‘label’],test_size=0.3)

Tahap 3. Memberi label encode pada variabel target

Encoder = LabelEncoder()
Train_Y = Encoder.fit_transform(Train_Y)
Test_Y = Encoder.fit_transform(Test_Y)

Tahap 4. Vektorkan kata-kata menggunakan TF-IDF Vectorizer

#Hal ini dilakukan untuk seberapa penting kata dalam

dokumen dalam perbandingan corpus
Tfidf_vect = TfidfVectorizer(max_features=5000)
Tfidf_vect.fit(Corpus[‘text_final’])
Train_X_Tfidf = Tfidf_vect.transform(Train_X)
Test_X_Tfidf = Tfidf_vect.transform(Test_X)

Tahap 5. Sekarang kita dapat menggunakan algoritma yang berbeda untuk mengklasifikasi
data untuk

#menguji akurasi
#DISINI dengan Algoritma Naive Bayes
 Natural Language Process (NLP): Machine Learning untuk Data Teks 115

#Serta mencocokkan data training pada klasifikasinya

(fitting)
Naive = naive_bayes.MultinomialNB()
Naive.fit(Train_X_Tfidf,Train_Y)
Luaran:
MultinomialNB(alpha=1.0, class_prior=None, fit_
prior=True)
# Menduga pelabelan pada himpunan data
predictions_NB = Naive.predict(Test_X_Tfidf)
# Menggunakan skor akurasi untuk mendapatkan nilai
akurasi
print(“Skor akurasi Naive Bayes-> “,accuracy_
score(predictions_NB, Test_Y)*100)
Luaran:
Skor akurasi Naive Bayes-> 83.1
# Klasifikasi algoritma SVM
#Cocokkan dengan data training pada hasil klasifikasi
SVM = svm.SVC(C=1.0, kernel=’linear’, degree=3,
gamma=’auto’)
SVM.fit(Train_X_Tfidf,Train_Y)
Luaran:
SVC(C=1.0, break_ties=False, cache_size=200, class_
weight=None, coef0=0.0,
decision_function_shape=’ovr’, degree=3,
gamma=’auto’, kernel=’linear’,
max_iter=-1, probability=False, random_state=None,
shrinking=True,
tol=0.001, verbose=False)
# Menduga hasil validasi pelabelan
predictions_SVM = SVM.predict(Test_X_Tfidf)
116 Machine Learning dengan Python

# Fungsi skor akurasi untuk melihat nilai akurasi SVM

print(“SVM Skore akurasi -> “,accuracy_
score(predictions_SVM, Test_Y)*100)
Luaran:
SVM Skore akurasi -> 84.7

Klasifikasi Amazon Review dengan sklearn

Pada bagian selanjutnya akan dicoba dengan menggunakan sklearn.
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import KFold

#Bagian ini dipanggil satu-satu dan dicoba, jika semua

ada yang error
models = []
models.append((‘KNN’, KNeighborsClassifier()))
models.append((‘SVC’, SVC()))
models.append((‘LR’, LogisticRegression()))
models.append((‘DT’, DecisionTreeClassifier()))
#models.append((‘GNB’, GaussianNB())) #Nach ini
ternyata tidak jalan
models.append((‘RF’, RandomForestClassifier()))
models.append((‘GB’, GradientBoostingClassifier()))

#Selanjutnya kita akan memasangkan data terhadap

setiap model dan menghitung akurasi
 Natural Language Process (NLP): Machine Learning untuk Data Teks 117

#setiap model dengan nilai akurasi.

names = []
scores = []
for name, model in models:
model.fit(Train_X_Tfidf, Train_Y)
y_pred = model.predict(Test_X_Tfidf)
scores.append(accuracy_score(Test_Y, y_pred))
names.append(name)
tr_split = pd.DataFrame({‘Nama’: names, ‘Nilai’:
scores})
print(tr_split)
Luaran:
Nama Nilai
0 KNN 0.712667
1 SVC 0.849667
2 LR 0.852000
3 DT 0.713667
4 RF 0.820000
5 GB 0.783000

Analisis: dari hasil ini diperoleh bahwa klasifikasi dengan LR paling tinggi.

3.3. Klasifikasi Spam Non-spam dengan Naive Bayes

Pada Bab 1 telah ditunjukkan bagaimana Naive Bayes dijelaskan dan contoh penggunaannya
pada pengolahan data. Pada bab ini, dibahas secara lengkap pemakaian metode Naive Bayes
untuk mengklasifikasikan e-mail ke dalam spam atau non-spam. Data file spam diberi kode 1
dan sebaliknya data non-spam diberi kode 0. Di sini diperagakan bagaimana Python digunakan
untuk membaca datasets e-mail spam dan nonspam, kemudian bagaimana melakukan
preparasi data, yaitu membuat list token dari email spam, nonspam dan keduanya, dalam
bentuk yang sudah bersih dari tag html, punktuasi, stopwords, serta melalui tahap stemming
118 Machine Learning dengan Python

(bentuk kata dasar). Di sini dipelajari cara menghitung probabilitas bayes dari datasets email
dan digunakan untuk memprediksi apakah email baru termasuk ke kategori spam atau tidak.
Di bagian terakhir diberikan juga cara memakai sklearn untuk melakukan hal yang sama.
Referensi yang cukup mudah dibaca telah diperoleh dari internet (Chauhan, 2018). Beberapa
referensi informal diperoleh pada beberapa alamat yang lain https://www.mdpi.com/1099-
4300/19/6/247/pdf; https://www.youtube.com/watch?v=O2L2Uv9pdDA.
Ketika membaca data, sebagaimana biasanya pada machine learning, kita perlu
membersihkan data. Pada bagian ini kita harus melihat apakah ada data email yang
kosong. Kalau ada, data kosong dihapus saja. Yang dimaksud dengan email kosong
adalah jika isi email tidak mengandung string apa pun, walaupun email tersebut mempunyai
ukuran file tidak nol. Mungkin hal itu karena email terkirim tanpa isi, atau file bukan email
yang tersimpan di database, dan lain-lain. Jadi kita akan mencari email kosong saja.
Secara ringkas, klasifikasi biner spam dan non-spam dilakukan dengan langkah-langkah
sebagai berikut:
1. Proses teks. Pada proses ini dilakukan pembersihan data mentah dan melakukan
tokenisasi. Pada proses pembersihan data terdapat tahapan, yaitu: kasus membuat huruf
menjadi semua huruf kecil (lowering), membuang karakter-karakter khusus (removal),
membuang kata-kata stop words, membuang hyperlinks, dan membuang spasi.
Contoh lowering: kata ‘TEXT’, ‘text’, ‘Text’ adalah sama nilainya dan ditulis sebagai ‘text’.
Contoh membuang karakter khusus: kata Hallo dan hallo! perlu menjadi ‘hallo’ saja.
Contoh stop words: kata the dan a memberikan pengertian yang sama sehingga perlu
dibuang karena tidak memberi arti tertentu pada suatu kata.
Contoh membuang hyperlinks: tentu pada bagian ini tidak perlu alamat URL sehingga
URL perlu dibuang.
2. Tokenisasi. Pada tokenisasi ini merupakan proses memecah teks menjadi beberapa
bagian kecil yang disebut token. Setiap token adalah input fitur pada algoritma machine
learning nantinya. Pada python terdapat fungsi keras.preprocessing.text.
Tokenizer yang melakukan tokenisasi atau membuat teks menjadi token-token dengan
menjaga kata-kata yang tetap paling sering muncul pada corpus. Jika tokenisasi selesai,
kita akan memperoleh sejumlah kamus kata-kata. Itu pun belum khusus. Masih perlu
dibatasi dengan parameter max-features yang menetapkan kata-kata yang frekuensi
tertinggi yang akan kita perhatikan.
 Natural Language Process (NLP): Machine Learning untuk Data Teks 119

max_feature = 50000
from keras. preprocessing.text
import Tokenizertokenizer = Tokenizer(num_words=max_
feature)

3. Pengurutan teks (Sequencing): pada bagian ini dilakukan padding dan encoding.
Padding, yaitu token dari semua e-mail dengan panjang sama di mana panjang semua
token yang maksimum ditandai dengan parameter ‘len’. Pada langkah selanjutnya adalah
memberikan pelabelan pada variabel target dengan encoding.
4. Pemilihan model. Model yang dimaksud di sini adalah model-model yang digunakan,
misalkan model klasifikasi yang digunakan ditetapkan terlebih dahulu. Contohnya, pada
subbab di atas digunakan model Naïve Bayes untuk klasifikasi email spam vs non-spam.
5. Implementasi. Pada tahap ini, kita kemudian melakukan coding untuk mengimplementasi
model yang sudah dipilih pada tahap sebelumnya sebagaimana ditunjukkan pada sub-
subbab berikut ini.

3.3.1. Program Python untuk Klasifikasi Spam dan Non-Spam

Langkah 0: Pada bagian ini kita mencari referensi terkait dengan menggunakan YouTube:
# Cara meletakkan YouTube di jupyter:

from IPython.display import HTML

Langkah 1:
“””## PERSIAPAN DATA”””
# Siapkan os untuk membaca file-file dalam folder
import os
# Di sini email dibaca satu per satu dengan walk.
# Untuk beralih dari file satu ke file berikutnya
dilakukan dengan
# membuat generator sebagai berikut:
# Jangan lupa pilih encoding=’latin-1’
def generator_iterasi_baca_email(lokasi):
for root, dirs, files in os.walk(lokasi,
120 Machine Learning dengan Python

topdown=False):
for file in files:
namafile=os.path.join(root, file)
#print(namafile)
bukafile=open(namafile,’r’,
encoding=’latin-1’)
simpan_baris=[] # isi email akan disimpan
disini
isi_email=False # awal baris adalah
header, bukan isi email
for baris in bukafile:
if isi_email: # Kalau sudah
diperoleh isi (awalnya belum ya)
simpan_baris.append(baris) #
simpanlah baris yang dibaca
elif (baris==’\n’): # Kalau diperoleh
baris kosong
isi_email=True # maka diperoleh
bagian isi
bukafile.close()
email=’’.join(simpan_baris) # baris-baris
yang ditemukan disambung jadi satu
yield email, file

# Kita buat fungsi baca email, hasil disimpan dalam suatu list, sekalian dengan informasi
klasifikasinya
# Klasifikasi = 0 adalah untuk non-spam, dan 1 untuk spam
def baca_semua_email(lokasi, klasifikasi):
dataemail=[]
for em, nf in generator_iterasi_baca_
 Natural Language Process (NLP): Machine Learning untuk Data Teks 121

email(lokasi):
dataemail.append({‘EMAIL’:em, ‘FILE’:nf,
‘FOLDER’:lokasi, ‘KLASIFIKASI’: klasifikasi})
return dataemail

# Tulislah semua folder lokasi data E-mail

FOLDER_SPAM_0=’../DATASETS/spam_0’
FOLDER_SPAM_1=’../DATASETS/spam_1’
FOLDER_SPAM_2=’../DATASETS/spam_2’
FOLDER_NONSPAM_0=’../DATASETS/easy_ham_0’
FOLDER_NONSPAM_1=’../DATASETS/easy_ham_1’
FOLDER_NONSPAM_2=’../DATASETS/easy_ham_2’

# Definisikan Klasifikasi

EMAIL_SPAM=1
EMAIL_NONSPAM=0

# Baca E-mail:

email=baca_semua_email(FOLDER_SPAM_0,EMAIL_SPAM)

# Tambahkan data dari folder lain:

email=email+baca_semua_email(FOLDER_SPAM_1,EMAIL_SPAM)
email=email+baca_semua_email(FOLDER_SPAM_2,EMAIL_SPAM)
email=email+baca_semua_email(FOLDER_NONSPAM_0,EMAIL_
NONSPAM)
email=email+baca_semua_email(FOLDER_NONSPAM_1,EMAIL_
NONSPAM)
email=email+baca_semua_email(FOLDER_NONSPAM_2,EMAIL_
NONSPAM)
122 Machine Learning dengan Python

# Kita memerlukan pandas untuk mempermudah mengelola data teks seperti di atas
# Dengan pandas kita bisa menampilkan data lebih menarik juga:

import pandas as pd

DATA=pd.DataFrame(email)

# untuk melihat 5 baris data pertama:

DATA.head()

Gambar 3.14 Hasil tampilan dataset spam

# Untuk melihat lima baris terakhir:

DATA.tail()

“””## MEMBERSIHKAN DATA

# apakah contoh ini kosong?

contoh=”hallo”
len(contoh)==0
Luaran:
False
 Natural Language Process (NLP): Machine Learning untuk Data Teks 123

# apakah contoh ini kosong?

contoh=””
len(contoh)==0
Luaran:
True

# Untuk melihat apakah ada yang kosong di dataFrame DATA pada kolom EMAIL:

DATA.EMAIL.str.len()==0
Luaran:
0 False
1 False
2 False
3 False
4 False
...
9744 False
9745 False
9746 False
9747 False
9748 True
Name: EMAIL, Length: 9749, dtype: bool

# Karena datanya panjang, maka kita lihat dengan perintah any():

# Jika True maka ada yang kosong

(DATA.EMAIL.str.len()==0).any()
Luaran:
True
124 Machine Learning dengan Python

# Ada berapa email kosong?

(DATA.EMAIL.str.len()==0).sum()
Luaran:
5

# Cara melihat data yang kosong:

DATA[DATA.EMAIL.str.len()==0].index
Int64Index([500, 1898, 3295, 8347, 9748],
dtype=’int64’)

# Cara melihat nama email dengan data kosong:

DATA[DATA.EMAIL.str.len()==0].FILE

500 cmds
1898 cmds
3295 cmds
8347 cmds
9748 cmds
Name: FILE, dtype: object

# Cara melihat data kosong:

DATA[DATA.EMAIL.str.len()==0]

# Cara menghapus data kosong

# Simpan dulu informasi yang mau dikosongkan:

hapus=DATA[DATA.EMAIL.str.len()==0].index
hapus
# sebelum hapus:
DATA.tail()
 Natural Language Process (NLP): Machine Learning untuk Data Teks 125

# cara menghapus dan meng-update:

DATA.drop(hapus, inplace=True)

# setelah hapus:

DATA.tail()

# Sekarang ada berapa email kosong?

(DATA.EMAIL.str.len()==0).sum()
Luaran:
0

# reset index

DATA.reset_index(inplace=True)
DATA.tail()

“””## MENGGAMBAR GRAFIK PIE”””

# Kita akan menggambar jumlah spam dan jumlah non-spam dalam sebuah grafik pie.
# untuk ini diperlukan matplotlib:

import matplotlib.pyplot as plt

# Kalau pakai jupyter, agar bisa menggambar secara langsung ketik perintah ini:

# %matplotlib inline

# Jumlah spam dan non-spam dapat dihitung melalui kolom KLASIFIKASI pada DATA:

DATA.KLASIFIKASI.value_counts()
Luaran:
0 6451
1 3293
Name: KLASIFIKASI, dtype: int64
126 Machine Learning dengan Python

# Jadi, jumlah masing-masing klasifikasi adalah:

jumlah_nonspam=DATA.KLASIFIKASI.value_counts()[0]
jumlah_spam=DATA.KLASIFIKASI.value_counts()[1]
print(‘Jumlah nonspam =’ , jumlah_nonspam)
print(‘Jumlah spam =’ , jumlah_spam)
Luaran:
Jumlah nonspam = 6451
Jumlah spam = 3293

# Sekarang kita gambar PIE-Chart:

nama_klasifikasi = [‘Spam’, ‘Nonspam’]

jumlah_klasifikasi = [jumlah_spam, jumlah_nonspam]
warna_klasifikasi = [‘lightblue’, ‘#557571’] # lihat
warna lain di colorhunt.co

plt.figure(figsize=(4, 4))
plt.pie(jumlah_klasifikasi,labels=nama_klasifikasi,
textprops={‘fontsize’: 20}, startangle=90,
autopct=’%1.0f%%’, colors=warna_klasifikasi,
explode=[0, 0.1])
plt.show()

“””Mau pilih warna yang lebih baik: buka colorhunt.co

![Screenshot%20%289641%29.png]
(attachment:Screenshot%20%289641%29.png)

## PROSES AWAL: lowering, tokenizing, cleaning, stemming

“””
# Kita ulang sebentar materi kuliah sebelumnya
# Membuat huruf menjadi kecil:
 Natural Language Process (NLP): Machine Learning untuk Data Teks 127

contoh=’Saya maKaN TOmaT’

contoh.lower()
Luaran:
‘saya makan tomat’

# tokenizing
kata=contoh.lower().split()
kata
Luaran:
[‘saya’, ‘makan’, ‘tomat’]
# cleaning (stopwording)
kata.remove(‘saya’)
kata
Luaran:
[‘makan’, ‘tomat’]

“””Di sini kita akan memakai librari NLTK untuk melakukan tokenizing, cleaning, dan
stemming.”””

import nltk
from nltk.tokenize import word_tokenize # untuk
tokenizing
from nltk.corpus import stopwords # daftar kata yang
dibuang
from nltk.stem import SnowballStemmer # untuk
stemming

# Kita perlu download data terbaru sebelum menggunakannya:

nltk.download(‘punkt’)
Luaran:
[nltk_data] Downloading package punkt to
[nltk_data] C:\Users\User\AppData\Roaming\nltk_
128 Machine Learning dengan Python

data...
[nltk_data] Package punkt is already up-to-date!
Out[36]:
True

nltk.download(‘stopwords’)
Luaran:
[nltk_data] Downloading package stopwords to
[nltk_data] C:\Users\User\AppData\Roaming\nltk_
data...
[nltk_data] Package stopwords is already up-to-date!
Out[37]:
True

contoh=’You are eating three Bananas’

kata=word_tokenize(contoh.lower())
kata
Luaran:
[‘you’, ‘are’, ‘eating’, ‘three’, ‘bananas’]

# Daftar stopwords tergantung bahasa:

kata_stop_en = set(stopwords.words(‘english’))
# Ada berapa kata stopwords di atas:
len(kata_stop_en)
Luaran:
179

# Isi stopwords:
kata_stop_en
Luaran:
 Natural Language Process (NLP): Machine Learning untuk Data Teks 129

{‘a’,
‘about’,
‘above’,
‘after’,
‘again’,
‘against’,
‘ain’,
‘all’,
‘am’,
‘an’,
‘and’,
‘any’,
‘are’,
‘aren’,
“aren’t”,
‘as’,
‘at’,
‘be’,
‘because’,
‘been’,
‘before’,
‘being’,
‘below’,
‘between’,
‘both’,
‘but’,
‘by’,
‘can’,
‘couldn’,
130 Machine Learning dengan Python

“couldn’t”,
‘d’,
‘did’,
‘didn’,
“didn’t”,
‘do’,
‘does’,
‘doesn’,
“doesn’t”,
‘doing’,
‘don’,
“don’t”,
‘down’,
‘during’,
‘each’,
‘few’,
‘for’,
‘from’,
‘further’,
‘had’,
‘hadn’,
“hadn’t”,
‘has’,
‘hasn’,
“hasn’t”,
‘have’,
‘haven’,
“haven’t”,
‘having’,
 Natural Language Process (NLP): Machine Learning untuk Data Teks 131

‘he’,
‘her’,
‘here’,
‘hers’,
‘herself’,
‘him’,
‘himself’,
‘his’,
‘how’,
‘i’,
‘if’,
‘in’,
‘into’,
‘is’,
‘isn’,
“isn’t”,
‘it’,
“it’s”,
‘its’,
‘itself’,
‘just’,
‘ll’,
‘m’,
‘ma’,
‘me’,
‘mightn’,
“mightn’t”,
‘more’,
‘most’,
132 Machine Learning dengan Python

‘mustn’,
“mustn’t”,
‘my’,
‘myself’,
‘needn’,
“needn’t”,
‘no’,
‘nor’,
‘not’,
‘now’,
‘o’,
‘of’,
‘off’,
‘on’,
‘once’,
‘only’,
‘or’,
‘other’,
‘our’,
‘ours’,
‘ourselves’,
‘out’,
‘over’,
‘own’,
‘re’,
‘s’,
‘same’,
‘shan’,
“shan’t”,
 Natural Language Process (NLP): Machine Learning untuk Data Teks 133

‘she’,
“she’s”,
‘should’,
“should’ve”,
‘shouldn’,
“shouldn’t”,
‘so’,
‘some’,
‘such’,
‘t’,
‘than’,
‘that’,
“that’ll”,
‘the’,
‘their’,
‘theirs’,
‘them’,
‘themselves’,
‘then’,
‘there’,
‘these’,
‘they’,
‘this’,
‘those’,
‘through’,
‘to’,
‘too’,
‘under’,
‘until’,
134 Machine Learning dengan Python

‘up’,
‘ve’,
‘very’,
‘was’,
‘wasn’,
“wasn’t”,
‘we’,
‘were’,
‘weren’,
“weren’t”,
‘what’,
‘when’,
‘where’,
‘which’,
‘while’,
‘who’,
‘whom’,
‘why’,
‘will’,
‘with’,
‘won’,
“won’t”,
‘wouldn’,
“wouldn’t”,
‘y’,
‘you’,
“you’d”,
“you’ll”,
“you’re”,
 Natural Language Process (NLP): Machine Learning untuk Data Teks 135

“you’ve”,
‘your’,
‘yours’,
‘yourself’,
‘yourselves’}

kata_stop_indo = set(stopwords.words(‘indonesian’))
kata_stop_indo
{‘ada’,
‘adalah’,
‘adanya’,
‘adapun’,
‘agak’,
‘agaknya’,
‘agar’,
‘akan’,
‘akankah’,
‘akhir’,
‘akhiri’,
‘akhirnya’,
‘aku’,
‘akulah’,
‘amat’,
‘amatlah’,
‘anda’,
‘andalah’,
‘antar’,
‘antara’,
‘antaranya’,
136 Machine Learning dengan Python

‘apa’,
‘apaan’,
‘apabila’,
‘apakah’,
‘apalagi’,
‘apatah’,
‘artinya’,
‘asal’,
‘asalkan’,
‘atas’,
‘atau’,
‘ataukah’,
‘ataupun’,
‘awal’,
‘awalnya’,
‘bagai’,
‘bagaikan’,
‘bagaimana’,
‘bagaimanakah’,
‘bagaimanapun’,
‘bagi’,
‘bagian’,
‘bahkan’,
‘bahwa’,
‘bahwasanya’,
‘baik’,
‘bakal’,
‘bakalan’,
‘balik’,
 Natural Language Process (NLP): Machine Learning untuk Data Teks 137

‘banyak’,
‘bapak’,
‘baru’,
‘bawah’,
‘beberapa’,
‘begini’,
‘beginian’,
‘beginikah’,
‘beginilah’,
‘begitu’,
‘begitukah’,
‘begitulah’,
‘begitupun’,
‘bekerja’,
‘belakang’,
‘belakangan’,
‘belum’,
‘belumlah’,
‘benar’,
‘benarkah’,
‘benarlah’,
‘berada’,
‘berakhir’,
‘berakhirlah’,
‘berakhirnya’,
‘berapa’,
‘berapakah’,
‘berapalah’,
‘berapapun’,
138 Machine Learning dengan Python

‘berarti’,
‘berawal’,
‘berbagai’,
‘berdatangan’,
‘beri’,
‘berikan’,
‘berikut’,
‘berikutnya’,
‘berjumlah’,
‘berkali-kali’,
‘berkata’,
‘berkehendak’,
‘berkeinginan’,
‘berkenaan’,
‘berlainan’,
‘berlalu’,
‘berlangsung’,
‘berlebihan’,
‘bermacam’,
‘bermacam-macam’,
‘bermaksud’,
‘bermula’,
‘bersama’,
‘bersama-sama’,
‘bersiap’,
‘bersiap-siap’,
‘bertanya’,
‘bertanya-tanya’,
‘berturut’,
 Natural Language Process (NLP): Machine Learning untuk Data Teks 139

‘berturut-turut’,
‘bertutur’,
‘berujar’,
‘berupa’,
‘besar’,
‘betul’,
‘betulkah’,
‘biasa’,
‘biasanya’,
‘bila’,
‘bilakah’,
‘bisa’,
‘bisakah’,
‘boleh’,
‘bolehkah’,
‘bolehlah’,
‘buat’,
‘bukan’,
‘bukankah’,
‘bukanlah’,
‘bukannya’,
‘bulan’,
‘bung’,
‘cara’,
‘caranya’,
‘cukup’,
‘cukupkah’,
‘cukuplah’,
‘cuma’,
140 Machine Learning dengan Python

‘dahulu’,
‘dalam’,
‘dan’,
‘dapat’,
‘dari’,
‘daripada’,
‘datang’,
‘dekat’,
‘demi’,
‘demikian’,
‘demikianlah’,
‘dengan’,
‘depan’,
‘di’,
‘dia’,
‘diakhiri’,
‘diakhirinya’,
‘dialah’,
‘diantara’,
‘diantaranya’,
‘diberi’,
‘diberikan’,
‘diberikannya’,
‘dibuat’,
‘dibuatnya’,
‘didapat’,
‘didatangkan’,
‘digunakan’,
‘diibaratkan’,
 Natural Language Process (NLP): Machine Learning untuk Data Teks 141

‘diibaratkannya’,
‘diingat’,
‘diingatkan’,
‘diinginkan’,
‘dijawab’,
‘dijelaskan’,
‘dijelaskannya’,
‘dikarenakan’,
‘dikatakan’,
‘dikatakannya’,
‘dikerjakan’,
‘diketahui’,
‘diketahuinya’,
‘dikira’,
‘dilakukan’,
‘dilalui’,
‘dilihat’,
‘dimaksud’,
‘dimaksudkan’,
‘dimaksudkannya’,
‘dimaksudnya’,
‘diminta’,
‘dimintai’,
‘dimisalkan’,
‘dimulai’,
‘dimulailah’,
‘dimulainya’,
‘dimungkinkan’,
‘dini’,
142 Machine Learning dengan Python

‘dipastikan’,
‘diperbuat’,
‘diperbuatnya’,
‘dipergunakan’,
‘diperkirakan’,
‘diperlihatkan’,
‘diperlukan’,
‘diperlukannya’,
‘dipersoalkan’,
‘dipertanyakan’,
‘dipunyai’,
‘diri’,
‘dirinya’,
‘disampaikan’,
‘disebut’,
‘disebutkan’,
‘disebutkannya’,
‘disini’,
‘disinilah’,
‘ditambahkan’,
‘ditandaskan’,
‘ditanya’,
‘ditanyai’,
‘ditanyakan’,
‘ditegaskan’,
‘ditujukan’,
‘ditunjuk’,
‘ditunjuki’,
‘ditunjukkan’,
 Natural Language Process (NLP): Machine Learning untuk Data Teks 143

‘ditunjukkannya’,
‘ditunjuknya’,
‘dituturkan’,
‘dituturkannya’,
‘diucapkan’,
‘diucapkannya’,
‘diungkapkan’,
‘dong’,
‘dua’,
‘dulu’,
‘empat’,
‘enggak’,
‘enggaknya’,
‘entah’,
‘entahlah’,
‘guna’,
‘gunakan’,
‘hal’,
‘hampir’,
‘hanya’,
‘hanyalah’,
‘hari’,
‘harus’,
‘haruslah’,
‘harusnya’,
‘hendak’,
‘hendaklah’,
‘hendaknya’,
‘hingga’,
144 Machine Learning dengan Python

‘ia’,
‘ialah’,
‘ibarat’,
‘ibaratkan’,
‘ibaratnya’,
‘ibu’,
‘ikut’,
‘ingat’,
‘ingat-ingat’,
‘ingin’,
‘inginkah’,
‘inginkan’,
‘ini’,
‘inikah’,
‘inilah’,
‘itu’,
‘itukah’,
‘itulah’,
‘jadi’,
‘jadilah’,
‘jadinya’,
‘jangan’,
‘jangankan’,
‘janganlah’,
‘jauh’,
‘jawab’,
‘jawaban’,
‘jawabnya’,
‘jelas’,
 Natural Language Process (NLP): Machine Learning untuk Data Teks 145

‘jelaskan’,
‘jelaslah’,
‘jelasnya’,
‘jika’,
‘jikalau’,
‘juga’,
‘jumlah’,
‘jumlahnya’,
‘justru’,
‘kala’,
‘kalau’,
‘kalaulah’,
‘kalaupun’,
‘kalian’,
‘kami’,
‘kamilah’,
‘kamu’,
‘kamulah’,
‘kan’,
‘kapan’,
‘kapankah’,
‘kapanpun’,
‘karena’,
‘karenanya’,
‘kasus’,
‘kata’,
‘katakan’,
‘katakanlah’,
‘katanya’,
146 Machine Learning dengan Python

‘ke’,
‘keadaan’,
‘kebetulan’,
‘kecil’,
‘kedua’,
‘keduanya’,
‘keinginan’,
‘kelamaan’,
‘kelihatan’,
‘kelihatannya’,
‘kelima’,
‘keluar’,
‘kembali’,
‘kemudian’,
‘kemungkinan’,
‘kemungkinannya’,
‘kenapa’,
‘kepada’,
‘kepadanya’,
‘kesampaian’,
‘keseluruhan’,
‘keseluruhannya’,
‘keterlaluan’,
‘ketika’,
‘khususnya’,
‘kini’,
‘kinilah’,
‘kira’,
‘kira-kira’,
 Natural Language Process (NLP): Machine Learning untuk Data Teks 147

‘kiranya’,
‘kita’,
‘kitalah’,
‘kok’,
‘kurang’,
‘lagi’,
‘lagian’,
‘lah’,
‘lain’,
‘lainnya’,
‘lalu’,
‘lama’,
‘lamanya’,
‘lanjut’,
‘lanjutnya’,
‘lebih’,
‘lewat’,
‘lima’,
‘luar’,
‘macam’,
‘maka’,
‘makanya’,
‘makin’,
‘malah’,
‘malahan’,
‘mampu’,
‘mampukah’,
‘mana’,
‘manakala’,
148 Machine Learning dengan Python

‘manalagi’,
‘masa’,
‘masalah’,
‘masalahnya’,
‘masih’,
‘masihkah’,
‘masing’,
‘masing-masing’,
‘mau’,
‘maupun’,
‘melainkan’,
‘melakukan’,
‘melalui’,
‘melihat’,
‘melihatnya’,
‘memang’,
‘memastikan’,
‘memberi’,
‘memberikan’,
‘membuat’,
‘memerlukan’,
‘memihak’,
‘meminta’,
‘memintakan’,
‘memisalkan’,
‘memperbuat’,
‘mempergunakan’,
‘memperkirakan’,
‘memperlihatkan’,
 Natural Language Process (NLP): Machine Learning untuk Data Teks 149

‘mempersiapkan’,
‘mempersoalkan’,
‘mempertanyakan’,
‘mempunyai’,
‘memulai’,
‘memungkinkan’,
‘menaiki’,
‘menambahkan’,
‘menandaskan’,
‘menanti’,
‘menanti-nanti’,
‘menantikan’,
‘menanya’,
‘menanyai’,
‘menanyakan’,
‘mendapat’,
‘mendapatkan’,
‘mendatang’,
‘mendatangi’,
‘mendatangkan’,
‘menegaskan’,
‘mengakhiri’,
‘mengapa’,
‘mengatakan’,
‘mengatakannya’,
‘mengenai’,
‘mengerjakan’,
‘mengetahui’,
‘menggunakan’,
150 Machine Learning dengan Python

‘menghendaki’,
‘mengibaratkan’,
‘mengibaratkannya’,
‘mengingat’,
‘mengingatkan’,
‘menginginkan’,
‘mengira’,
‘mengucapkan’,
‘mengucapkannya’,
‘mengungkapkan’,
‘menjadi’,
‘menjawab’,
‘menjelaskan’,
‘menuju’,
‘menunjuk’,
‘menunjuki’,
‘menunjukkan’,
‘menunjuknya’,
‘menurut’,
‘menuturkan’,
‘menyampaikan’,
‘menyangkut’,
‘menyatakan’,
‘menyebutkan’,
‘menyeluruh’,
‘menyiapkan’,
‘merasa’,
‘mereka’,
‘merekalah’,
 Natural Language Process (NLP): Machine Learning untuk Data Teks 151

‘merupakan’,
‘meski’,
‘meskipun’,
‘meyakini’,
‘meyakinkan’,
‘minta’,
‘mirip’,
‘misal’,
‘misalkan’,
‘misalnya’,
‘mula’,
‘mulai’,
‘mulailah’,
‘mulanya’,
‘mungkin’,
‘mungkinkah’,
‘nah’,
‘naik’,
‘namun’,
‘nanti’,
‘nantinya’,
‘nyaris’,
‘nyatanya’,
‘oleh’,
‘olehnya’,
‘pada’,
‘padahal’,
‘padanya’,
‘pak’,
152 Machine Learning dengan Python

‘paling’,
‘panjang’,
‘pantas’,
‘para’,
‘pasti’,
‘pastilah’,
‘penting’,
‘pentingnya’,
‘per’,
‘percuma’,
‘perlu’,
‘perlukah’,
‘perlunya’,
‘pernah’,
‘persoalan’,
‘pertama’,
‘pertama-tama’,
‘pertanyaan’,
‘pertanyakan’,
‘pihak’,
‘pihaknya’,
‘pukul’,
‘pula’,
‘pun’,
‘punya’,
‘rasa’,
‘rasanya’,
‘rata’,
‘rupanya’,
 Natural Language Process (NLP): Machine Learning untuk Data Teks 153

‘saat’,
‘saatnya’,
‘saja’,
‘sajalah’,
‘saling’,
‘sama’,
‘sama-sama’,
‘sambil’,
‘sampai’,
‘sampai-sampai’,
‘sampaikan’,
‘sana’,
‘sangat’,
‘sangatlah’,
‘satu’,
‘saya’,
‘sayalah’,
‘se’,
‘sebab’,
‘sebabnya’,
‘sebagai’,
‘sebagaimana’,
‘sebagainya’,
‘sebagian’,
‘sebaik’,
‘sebaik-baiknya’,
‘sebaiknya’,
‘sebaliknya’,
‘sebanyak’,
154 Machine Learning dengan Python

‘sebegini’,
‘sebegitu’,
‘sebelum’,
‘sebelumnya’,
‘sebenarnya’,
‘seberapa’,
‘sebesar’,
‘sebetulnya’,
‘sebisanya’,
‘sebuah’,
‘sebut’,
‘sebutlah’,
‘sebutnya’,
‘secara’,
‘secukupnya’,
‘sedang’,
‘sedangkan’,
‘sedemikian’,
‘sedikit’,
‘sedikitnya’,
‘seenaknya’,
‘segala’,
‘segalanya’,
‘segera’,
‘seharusnya’,
‘sehingga’,
‘seingat’,
‘sejak’,
‘sejauh’,
 Natural Language Process (NLP): Machine Learning untuk Data Teks 155

‘sejenak’,
‘sejumlah’,
‘sekadar’,
‘sekadarnya’,
‘sekali’,
‘sekali-kali’,
‘sekalian’,
‘sekaligus’,
‘sekalipun’,
‘sekarang’,
‘sekecil’,
‘seketika’,
‘sekiranya’,
‘sekitar’,
‘sekitarnya’,
‘sekurang-kurangnya’,
‘sekurangnya’,
‘sela’,
‘selain’,
‘selaku’,
‘selalu’,
‘selama’,
‘selama-lamanya’,
‘selamanya’,
‘selanjutnya’,
‘seluruh’,
‘seluruhnya’,
‘semacam’,
‘semakin’,
156 Machine Learning dengan Python

‘semampu’,
‘semampunya’,
‘semasa’,
‘semasih’,
‘semata’,
‘semata-mata’,
‘semaunya’,
‘sementara’,
‘semisal’,
‘semisalnya’,
‘sempat’,
‘semua’,
‘semuanya’,
‘semula’,
‘sendiri’,
‘sendirian’,
‘sendirinya’,
‘seolah’,
‘seolah-olah’,
‘seorang’,
‘sepanjang’,
‘sepantasnya’,
‘sepantasnyalah’,
‘seperlunya’,
‘seperti’,
‘sepertinya’,
‘sepihak’,
‘sering’,
‘seringnya’,
 Natural Language Process (NLP): Machine Learning untuk Data Teks 157

‘serta’,
‘serupa’,
‘sesaat’,
‘sesama’,
‘sesampai’,
‘sesegera’,
‘sesekali’,
‘seseorang’,
‘sesuatu’,
‘sesuatunya’,
‘sesudah’,
‘sesudahnya’,
‘setelah’,
‘setempat’,
‘setengah’,
‘seterusnya’,
‘setiap’,
‘setiba’,
‘setibanya’,
‘setidak-tidaknya’,
‘setidaknya’,
‘setinggi’,
‘seusai’,
‘sewaktu’,
‘siap’,
‘siapa’,
‘siapakah’,
‘siapapun’,
‘sini’,
158 Machine Learning dengan Python

‘sinilah’,
‘soal’,
‘soalnya’,
‘suatu’,
‘sudah’,
‘sudahkah’,
‘sudahlah’,
‘supaya’,
‘tadi’,
‘tadinya’,
‘tahu’,
‘tahun’,
‘tak’,
‘tambah’,
‘tambahnya’,
‘tampak’,
‘tampaknya’,
‘tandas’,
‘tandasnya’,
‘tanpa’,
‘tanya’,
‘tanyakan’,
‘tanyanya’,
‘tapi’,
‘tegas’,
‘tegasnya’,
‘telah’,
‘tempat’,
‘tengah’,
 Natural Language Process (NLP): Machine Learning untuk Data Teks 159

‘tentang’,
‘tentu’,
‘tentulah’,
‘tentunya’,
‘tepat’,
‘terakhir’,
‘terasa’,
‘terbanyak’,
‘terdahulu’,
‘terdapat’,
‘terdiri’,
‘terhadap’,
‘terhadapnya’,
‘teringat’,
‘teringat-ingat’,
‘terjadi’,
‘terjadilah’,
‘terjadinya’,
‘terkira’,
‘terlalu’,
‘terlebih’,
‘terlihat’,
‘termasuk’,
‘ternyata’,
‘tersampaikan’,
‘tersebut’,
‘tersebutlah’,
‘tertentu’,
‘tertuju’,
160 Machine Learning dengan Python

‘terus’,
‘terutama’,
‘tetap’,
‘tetapi’,
‘tiap’,
‘tiba’,
‘tiba-tiba’,
‘tidak’,
‘tidakkah’,
‘tidaklah’,
‘tiga’,
‘tinggi’,
‘toh’,
‘tunjuk’,
‘turut’,
‘tutur’,
‘tuturnya’,
‘ucap’,
‘ucapnya’,
‘ujar’,
‘ujarnya’,
‘umum’,
‘umumnya’,
‘ungkap’,
‘ungkapnya’,
‘untuk’,
‘usah’,
‘usai’,
‘waduh’,
 Natural Language Process (NLP): Machine Learning untuk Data Teks 161

‘wah’,
‘wahai’,
‘waktu’,
‘waktunya’,
‘walau’,
‘walaupun’,
‘wong’,
‘yaitu’,
‘yakin’,
‘yakni’,
‘yang’}

# Cara menghilangkan kata yang ada di kategori stopwords:

contoh=’You are eating three Bananas’

kata=word_tokenize(contoh.lower())
for k in kata:
if k in kata_stop_en:
kata.remove(k)
kata
Luaran:
[‘are’, ‘eating’, ‘three’, ‘bananas’]

# Cara lain adalah membuat list baru yang tidak terdapat di stopwords:

contoh=’Are you eating three Bananas? Dont eat too

much!’
kata=word_tokenize(contoh.lower())
kata_baru=[]
for k in kata:
if k not in kata_stop_en:
kata_baru.append(k)
162 Machine Learning dengan Python

kata_baru
Luaran:
[‘eating’, ‘three’, ‘bananas’, ‘?’, ‘dont’, ‘eat’,
‘much’, ‘!’]

# Coba bedakan dengan perintah split. Pungtuasi tidak ikut terpisah:

contoh.lower().split()
Luaran:
[‘are’, ‘you’, ‘eating’, ‘three’, ‘bananas?’, ‘dont’,
‘eat’, ‘too’, ‘much!’]

‘a’.isalpha()
Luaran:
True
‘?’.isalpha()
Luaran:
False

# Buat list baru yang tidak terdapat di stopwords dan bukan pungtuasi:

contoh=’Are you eating three Bananas? Dont eat too

much!’
kata=word_tokenize(contoh.lower())
kata_baru=[]
for k in kata:
if k not in kata_stop_en and k.isalpha():
kata_baru.append(k)
kata_baru

Luaran:
[‘eating’, ‘three’, ‘bananas’, ‘dont’, ‘eat’, ‘much’]
 Natural Language Process (NLP): Machine Learning untuk Data Teks 163

# Cara stemming (mengubah jadi kata dasar):

stemmer = SnowballStemmer(‘english’)
kata=’organization’
kata_dasar=stemmer.stem(kata)
kata_dasar
Luaran:
‘organ’

# Cobalah sekarang membuat rangkaian: lowering,

tokenizing, cleaning, dan stemming:
contoh=’Are you eating three Bananas? Do not eat too
much!’
stemmer = SnowballStemmer(‘english’)
kata=word_tokenize(contoh.lower())
kata_baru=[]
for k in kata:
if k not in kata_stop_en and k.isalpha():
kata_dasar=stemmer.stem(k)
kata_baru.append(kata_dasar)
kata_baru
Luaran:
[‘eat’, ‘three’, ‘banana’, ‘eat’, ‘much’]

“””## MEMBERSIHKAN TAG HTML”””

# Coba lihat isi email tertentu:

DATA.at[0,’EMAIL’]

Luaran:
164 Machine Learning dengan Python

# Kita butuh librari untuk membersihkan tag dan membuat e-mail di atas terbaca dengan
lebih baik.

from bs4 import BeautifulSoup

# Rapikan format html dengan BeautifulSoup

contoh=BeautifulSoup(DATA.at[0, ‘EMAIL’], ‘html.

parser’)
print(contoh.prettify())
Luaran:
<!DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.0
Transitional//EN”>
<html>
<head>
<meta charset=”utf-8” content=’3D”text/html;’ http-
equiv=”3DContent-T=” ype=””/>
<meta 5.00.2314.1000”=”” content=’3D”MSHTML’
name=”3DGENERATOR”/>
</head>
<body>
<!-- Inserted by Calypso -->
<table black;=”” border=”3D0” cellpadding=”3D0”
cellspacing=”3D2” display:=”” id=”3D_CalyPrintHeader_”
none”=”” r=”ules=3Dnone” style=’3D”COLOR:’
width=’3D”100%”’>
<tbody>
<tr>
<td colspan=”3D3”>
<hr color=”3Dblack” noshade=”” size=”3D1”/>
</td>
</tr>
 Natural Language Process (NLP): Machine Learning untuk Data Teks 165

</tbody>
</table>
</body>
</html>
<tr>
<td colspan=”3D3”>
<hr color=”3Dblack” noshade=”” size=”3D1”/>
</td>
</tr>
<!-- End Calypso -->
<!-- Inserted by Calypso=
-->
<font color=”3D#000000”
face=”3DVERDANA,ARIAL,HELVETICA” size=”3D-2”>
<br/>
</font>
&lt;=
/TR&gt;
<!-- End Calypso -->
<font bold”=”” color=”3D#ff0000” face=’3D”Copperplate’
gothic=”” ptsize=’3D”10”’ size=”3D5”>
<center>
Save up to 70% on Life Insurance.
</center>
</font>
<font 0000=”” bold”=”” color=”3D#ff=”
face=’3D”Copperplate’ gothic=”” ptsize=’3D”10”’
size=”3D5”>
<center>
Why Spend More Than You Have To?
166 Machine Learning dengan Python

<center>
<font bold”=”” color=”3D#ff0000”
face=’3D”Copperplate’ gothic=”” pt=’SIZE=3D”10”’
size=”3D5”>
<center>
Life Quote Savings
<center>
<p align=”3Dleft”>
</p>
<p align=”3Dleft”>
</p>
</center>
</center>
</font>
</center>
</center>
</font>
<br/>
<p>
</p>
<center>
<table border=”3D0” bordercolor=”3D#111111”
cellpadding=”3D0” cellspacing=”3D0” wi=”dth=3D650”>
<tbody>
</tbody>
</table>
<table border=”3D0” bordercolor=”3D#111111”
cellpadding=”3D5” cellspacing=”3D0” wi=”dth=3D650”>
<tbody>
<tr>
 Natural Language Process (NLP): Machine Learning untuk Data Teks 167

<td colspan=”3D2” width=’3D”35%”’>

<b>
<font face=”3DVerdana” size=”3D4”>
Ensurin=g your
family’s financial security is very important.
Life Quote Savings makes
buying life insurance simple and affordable. We
Provide FREE Access =to The Very Best Companies and
The Lowest Rates.
</font>
</b>
</td>
</tr>
<tr>
<td align=”3Dmiddle” valign=”3Dtop”
width=’3D”18%”’>
<table bordercolor=”3D#111111” width=’3D”100%”’>
<tbody>
<tr>
<td %”=”” 5px”=”” 5px;=”” padding-right:=””
style=’3D”PADDING-LEFT:’ width=’3D”100=’>
<font face=”3DVerdana” size=”3D4”>
<b>
Life Quote Savings
</b>
is FAST, EAS=Y and SAVES you money! Let us
help you get started with the best values in
the country on new coverage. You can SAVE
hundreds or even thousands of dollars by requesting a
FREE quote from Lifequote Savings. =
168 Machine Learning dengan Python

Our service will take you less than 5 minutes to

complete. Shop and
compare. SAVE up to 70% on all types of
Life insurance!
</font>
</td>
</tr>
<tr>
<br/>
<br/>
<td 5px”=”” 5px;=”” height=”3D50” padding-
right:=”” style=’3D”PADDING -LEFT:’ width=’3D”100%”’>
<p align=”3Dcenter”>
<b>
<font face=”3DVerdana” size=”3D5”>
<a href=’3D”http://website.e365.cc/
savequote/”’>
Click Here For Your=

Free Quote!
</a>
</font>
</b>
</p>
</td>
<p>
<font face=”3DVerdana” size=”3D4”>
<strong>
<center>
Protecting your family is the best
 Natural Language Process (NLP): Machine Learning untuk Data Teks 169

investment you’ll ever

make!
<br/>
</center>
</strong>
</font>
</p>
</tr>
</tbody>
</table>
</td>
</tr>
</tbody>
</table>
</center>
<tr>
<br/>
<br/>
</tr>
<tr>
</tr>
<p align=”3Dleft”>
<font face=’3D”Arial,’ helvetica,=”” sans-serif”=””
size=”3D2=”>
</font>
</p>
<p>
</p>
<center>
170 Machine Learning dengan Python

<br/>
<br/>
<br/>
<p>
</p>
<p align=”3Dleft”>
<br/>
</p>
</center>
<br/>
<br/>
<br/>
<br/>
<p align=”3Dcenter”>
<br/>
</p>
<p align=”3Dleft”>
<br/>
</p>
<br/>
<br/>
If you are in receipt of this=
email
in error and/or wish to be removed from our
list,
<a href=’3D”mailto:[email protected]”’>
PLEASE CLICK HERE
</a>
AND TYPE =
 Natural Language Process (NLP): Machine Learning untuk Data Teks 171

REMOVE. If you
reside in any state which prohibits e-mail
solicitations for insuran=
ce,
please disregard this
email.
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<br=>
<br/>
<br/>
<br/>
</br=>
<!--=
CENTER-->

In [55]:
172 Machine Learning dengan Python

# Ambil text-nya saja:

print(contoh.get_text())
Luaran:
<=
/TR>
Save up to 70% on Life Insurance.
Why Spend More Than You Have To?

Life Quote Savings

Ensurin=
g your
family’s financial security is very important.
Life Quote Savings ma=
kes
buying life insurance simple and affordable. We
Provide FREE Access =
to The
Very Best Companies and The Lowest Rates.

Life Quote Savings is FAST, EAS=

Y and
SAVES you money! Let us help you get
started with the best val=
ues in
the country on new coverage. You can SAVE
hundreds or even tho=
usands
of dollars by requesting a FREE quote from
Lifequote Savings. =
Our
 Natural Language Process (NLP): Machine Learning untuk Data Teks 173

service will take you less than 5 minutes

to complete. Shop an=
d
compare. SAVE up to 70% on all types of
Life insurance!

Click Here For Your=

Free Quote!

Protecting your family is the best investment you’ll

eve=
r
make!

If you are in receipt of this=

email
in error and/or wish to be removed from our
list, PLEASE CLICK HERE AND TYPE =
REMOVE. If you
reside in any state which prohibits e-mail
solicitations for insuran=
ce,
please disregard this
email.
174 Machine Learning dengan Python

# Nah, coba sekarang lakukan rangkaian: buang tag html, lowering, tokenizing, cleaning,
dan stemming:

contoh=DATA.at[0,’EMAIL’] # data awal

contoh=BeautifulSoup(contoh, ‘html.parser’).get_text()
# buang tag
kata=word_tokenize(contoh.lower()) # lowering,
tokenizing
kata_baru=[]
for k in kata:
if k not in kata_stop_en and k.isalpha(): #
cleaning
kata_dasar=stemmer.stem(k) # stemming
kata_baru.append(kata_dasar)
kata_baru
Luaran:
[‘save’,
‘life’,
‘insur’,
‘spend’,
‘life’,
‘quot’,
‘save’,
‘g’,
‘famili’,
‘financi’,
‘secur’,
‘import’,
‘life’,
‘quot’,
 Natural Language Process (NLP): Machine Learning untuk Data Teks 175

‘save’,
‘kes’,
‘buy’,
‘life’,
‘insur’,
‘simpl’,
‘afford’,
‘provid’,
‘free’,
‘access’,
‘best’,
‘compani’,
‘lowest’,
‘rate’,
‘life’,
‘quot’,
‘save’,
‘fast’,
‘save’,
‘money’,
‘let’,
‘us’,
‘help’,
‘get’,
‘start’,
‘best’,
‘ue’,
‘countri’,
‘new’,
176 Machine Learning dengan Python

‘coverag’,
‘save’,
‘hundr’,
‘even’,
‘usand’,
‘dollar’,
‘request’,
‘free’,
‘quot’,
‘lifequot’,
‘save’,
‘servic’,
‘take’,
‘less’,
‘minut’,
‘complet’,
‘shop’,
‘compar’,
‘save’,
‘type’,
‘life’,
‘insur’,
‘click’,
‘free’,
‘quot’,
‘protect’,
‘famili’,
‘best’,
‘invest’,
 Natural Language Process (NLP): Machine Learning untuk Data Teks 177

‘r’,
‘make’,
‘receipt’,
‘email’,
‘error’,
‘wish’,
‘remov’,
‘list’,
‘pleas’,
‘click’,
‘type’,
‘remov’,
‘resid’,
‘state’,
‘prohibit’,
‘solicit’,
‘ce’,
‘pleas’,
‘disregard’,
‘email’]

# Buatlah fungsi pra-proses yang memproses e-mail seperti di atas:

def praproses(pesan,
stemmer=SnowballStemmer(‘english’), kata_stop =
set(stopwords.words(‘english’))):
tanpa_tag=BeautifulSoup(pesan, ‘html.parser’).get_
text() # buang tag
kata=word_tokenize(tanpa_tag.lower()) # lowering,
tokenizing
kata_baru=[]
178 Machine Learning dengan Python

for k in kata:
if k not in kata_stop and k.isalpha(): #
cleaning
kata_dasar=stemmer.stem(k) # stemming
kata_baru.append(kata_dasar)
return kata_baru

praproses(‘<div name=”something”><h1>Are you eating

three bananas?? Do not eat too much!</h1></div>’)
Luaran:
[‘eat’, ‘three’, ‘banana’, ‘eat’, ‘much’]

# Sekarang kita akan mengaplikasikan fungsi tersebut untuk seluruh data e-mail.
# Tetapi, kita perlu coba dulu dengan beberapa e-mail saja.
# Coba baca data 2 e-mail pertama saja:

DATA.EMAIL.iloc[0:2]
Luaran:
0 <!DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.0 Tr...
1 1) Fight The Risk of Cancer!\nhttp://www.adcli...
Name: EMAIL, dtype: object

# Aplikasikan pra-poses pada 2 e-mail urutan 10 dan 11:

contoh=DATA.EMAIL.iloc[10:12].apply(praproses)
contoh
Luaran:
10 [cellular, phone, accessori, wholesal, price,
...
11 [click, simpli, amateur, like, girl, next,
doo...
Name: EMAIL, dtype: object
 Natural Language Process (NLP): Machine Learning untuk Data Teks 179

type(contoh)
Luaran:
pandas.core.series.Series

# Termasuk dalam klasifikasi apakah 2 e-mail di atas?

contoh.index
Luaran:
RangeIndex(start=10, stop=12, step=1)

DATA.iloc[contoh.index]

DATA.iloc[contoh.index].KLASIFIKASI
10 1
11 1
Name: KLASIFIKASI, dtype: int64

# Sekarang untuk semua data, ukurlah waktu prosesnya.

# Commented out IPython magic to ensure Python

compatibility.
# %%time
#
# list_token=DATA.EMAIL.apply(praproses)

len(list_token)
list_token
0 [save, life, insur, spend, life, quot, save,
g...
1 [fight, risk, cancer, http, slim, guarante,
lo...
2 [fight, risk, cancer, http, slim, guarante,
lo...
180 Machine Learning dengan Python

3 [adult, club, offer, free, membership,

instant...
4 [thought, might, like, slim, guarante, lose,
l...
...
9739 [http, bizarr, collect, stuf, anim, could,
fet...
9740 [care, use, one, also, realli, cute, thing,
ja...
9741 [sm, skip, montanaro, write, jeremi, put,
anot...
9742 [mark, hammond, like, given, zodb, sound,
attr...
9743 [hi, probabl, use, whatsoev, also, problem,
re...
Name: EMAIL, Length: 9744, dtype: object
DATA.tail()

# Kita akan membuat list token gabungan dari seluruh e-mail (list_token yang tadi adalah
token tiap e-mail).

list_token_gabungan=[]
for daftar in list_token:
for kata in daftar:
list_token_gabungan.append(kata)
len(list_token_gabungan)
Luaran:
1269100

# Carilah indeks e-mail spam:

index_spam=DATA[DATA.KLASIFIKASI==1].index
index_spam
 Natural Language Process (NLP): Machine Learning untuk Data Teks 181

Luaran:
Int64Index([ 0, 1, 2, 3, 4, 5, 6,
7, 8, 9,
...
3283, 3284, 3285, 3286, 3287, 3288, 3289,
3290, 3291, 3292],
dtype=’int64’, length=3293)

# Carilah indeks e-mail non-spam:

index_nonspam=DATA[DATA.KLASIFIKASI==0].index
index_nonspam
Luaran:
Int64Index([3293, 3294, 3295, 3296, 3297, 3298, 3299,
3300, 3301, 3302,
...
9734, 9735, 9736, 9737, 9738, 9739, 9740,
9741, 9742, 9743],
dtype=’int64’, length=6451)

# Buatlah daftar dari list_token yang masuk klasifikasi spam:

list_spam=list_token[index_spam]
list_spam
Luaran:
0 [save, life, insur, spend, life, quot, save,
g...
1 [fight, risk, cancer, http, slim, guarante,
lo...
2 [fight, risk, cancer, http, slim, guarante,
lo...
3 [adult, club, offer, free, membership,
instant...
182 Machine Learning dengan Python

4 [thought, might, like, slim, guarante, lose,

l...
...
3288 [want, boss, train, home, studi, thousand,
peo...
3289 [messag, mime, format, prefer, doctor, order,
...
3290 [dear, subscrib, could, show, way, get,
visito...
3291 [custom, appreci, sale, express, appreci,
loya...
3292 [attn, strict, confidenti, pleas, introduc,
na...
Name: EMAIL, Length: 3293, dtype: object

# Buatlah daftar dari list_token yang masuk klasifikasi non-spam:

list_nonspam=list_token[index_nonspam]
list_nonspam
3293 [date, wed, aug, chris, garrigu, ca,
reproduc,...
3294 [martin, post, tasso, papadopoulo, greek,
scul...
3295 [man, threaten, explos, moscow, thursday,
augu...
3296 [klez, virus, wo, die, alreadi, prolif,
virus,...
3297 [wed, aug, ulis, ponc, wrote, hi, command,
ins...
...
9739 [http, bizarr, collect, stuf, anim, could,
fet...
 Natural Language Process (NLP): Machine Learning untuk Data Teks 183

9740 [care, use, one, also, realli, cute, thing,

ja...
9741 [sm, skip, montanaro, write, jeremi, put,
anot...
9742 [mark, hammond, like, given, zodb, sound,
attr...
9743 [hi, probabl, use, whatsoev, also, problem,
re...
Name: EMAIL, Length: 6451, dtype: object

# Nah, sekarang jadikan list_spam menjadi satu list panjang:

list_token_spam=[]
for daftar in list_spam:
for kata in daftar:
list_token_spam.append(kata)

# Begitu juga jadikan list_nonspam menjadi satu list panjang:

list_token_nonspam=[]
for daftar in list_nonspam:
for kata in daftar:
list_token_nonspam.append(kata)

print(len(list_token_spam))
print(len(list_token_nonspam))
print(len(list_token_gabungan))
Luaran:
557699
711401
1269100

# Data set yang besar:

184 Machine Learning dengan Python

551845+712498
Luaran:
1264343

3.4. Klasifikasi dengan WordCloud

# Kita akan mencoba menggambar statistik kata-kata yang sudah kita susun di atas. untuk itu
kita memerlukan: WordCloud. Untuk itu, kita perlu instal WordCloud. Jika pada anaconda, kita
dapat instal pada menu anaconda, yaitu: pip instal WordCloud
Di bawah ini dilakukan sesudah kita sukses menginstal WordCloud.

from WordCloud import WordCloud

# Pertama, kita harus sambung list_token_spam menjadi 1 kalimat panjang.

contoh=[‘saya’, ‘makan’, ‘tahu’]

gabung=’ ‘.join(contoh)
gabung
Luaran:
‘saya makan tahu’
spam_gabung=’ ‘.join(list_token_spam)

awan_kata= WordCloud(background_color=’white’,
max_words=500, colormap=’ocean’)
awan_kata.generate(spam_gabung)
Luaran:
<WordCloud.WordCloud.WordCloud at 0x2e722ec1048>
plt.figure(figsize=[10, 10])
plt.imshow(awan_kata, interpolation=’bilinear’)
plt.axis(‘off’)
plt.show()
nonspam_gabung=’ ‘.join(list_token_nonspam)
 Natural Language Process (NLP): Machine Learning untuk Data Teks 185

awan_kata.generate(nonspam_gabung)
plt.figure(figsize=[10, 10])
plt.imshow(awan_kata, interpolation=’bilinear’)
plt.axis(‘off’)
plt.show()

gabungan_gabung=’ ‘.join(list_token_gabungan)
awan_kata.generate(gabungan_gabung)
plt.figure(figsize=[10, 10])
plt.imshow(awan_kata, interpolation=’bilinear’)
plt.axis(‘off’)
plt.show()

3.4.1. Melakukan Vektorisasi Token

Kita akan membuat 4 DataFrame, yaitu:
1. DataFrame token_vek, berisi token setiap e-mail yang sudah dibersihkan, dalam sebuah
tabel jumlah token tiap e-mail. Ini menjadi data features.
2. DataFrame klasifikasi_vek, berisi vektor klasifikasi spam atau non-spam.
3. DataFrame email_vek, berisi token e-mail yang sudah dirangkai menjadi satu untuk
masing-masing e-mail.
4. DataFrame vokab_vek, berisi vokabulari yang dipakai untuk menyusun tabel DataFrame
token_vek.

def vektor_email(pesan):
vektor=[]
for item in pesan:
item_vek={}
for kata in item:
item_vek.update({kata : kata.count(kata)})
vektor+=[item_vek]
186 Machine Learning dengan Python

token_vektor=pd.DataFrame(vektor).fillna(0).
astype(int)
return token_vektor
token_vek=vektor_email(list_token)
token_vek.head()
vokab_indeks=token_vek.columns
vokab_vek=pd.DataFrame(index=range(len(vokab_
indeks)),data=vokab_indeks)
vokab_vek.head()
email_vek=list_token.apply(lambda x: ‘ ‘.join(x))
email_vek[0:10]
Luaran:
0 save life insur spend life quot save g famili ...
1 fight risk cancer http slim guarante lose lbs ...
2 fight risk cancer http slim guarante lose lbs ...
3 adult club offer free membership instant acces...
4 thought might like slim guarante lose lbs day ...
5 powerhous gift program want miss get founder m...
6 help want year old fortun compani grow tremend...
7 reliaquot save life insur life chang instant i...
8 tire bull want stop lose money want real money...
9 dear cost effect direct email advertis promot ...
Name: EMAIL, dtype: object
klasifikasi_vek=DATA.KLASIFIKASI
klasifikasi_vek[0:10]

Luaran:
0 1
1 1
2 1
 Natural Language Process (NLP): Machine Learning untuk Data Teks 187

3 1
4 1
5 1
6 1
7 1
8 1
9 1
Name: KLASIFIKASI, dtype: int64

# Berapa jumlah e-mail spam dan non-spam masing-masing?

klasifikasi_vek.value_counts()
Luaran:
0 6451
1 3293
Name: KLASIFIKASI, dtype: int64

# Di manakah baris e-mail spam?

indeks_spam=klasifikasi_vek[klasifikasi_vek==1].index
indeks_spam
Luaran:
Int64Index([ 0, 1, 2, 3, 4, 5, 6,
7, 8, 9,
...
3283, 3284, 3285, 3286, 3287, 3288, 3289,
3290, 3291, 3292],
dtype=’int64’, length=3293)

# Di manakah baris e-mail non-spam?

indeks_nonspam=klasifikasi_vek[klasifikasi_vek==0].index
indeks_nonspam
Luaran:
188 Machine Learning dengan Python

Int64Index([3293, 3294, 3295, 3296, 3297, 3298, 3299,

3300, 3301, 3302,
...
9734, 9735, 9736, 9737, 9738, 9739, 9740,
9741, 9742, 9743],
dtype=’int64’, length=6451)

# Cek ukuran

print(len(indeks_nonspam))
print(len(indeks_spam))
print(len(klasifikasi_vek))
print(len(token_vek))
len(indeks_nonspam)+len(indeks_spam)
Luaran:
6451
3293
9744
9744
Out[153]:
9744

token_vek.tail()

# Coba lihat vektor token untuk spam saja.

token_vek.iloc[indeks_spam].head()

# Berapa jumlah masing-masing token di spam?

token_vek.iloc[indeks_spam].sum()
save 518
life 496
insur 284
 Natural Language Process (NLP): Machine Learning untuk Data Teks 189

spend 124
quot 238
...
glxgear 0
cack 0
stil 0
kdm 0
xserver 0
Length: 27220, dtype: int64

# Berapa jumlah masing-masing token di non-spam?

token_vek.iloc[indeks_nonspam].sum
<bound method DataFrame.sum of save life insur
spend quot g famili financi secur import ... \
3293 0 0 0 0 0 0 0 0
0 0 ...
3294 0 0 0 0 0 0 0 0
0 0 ...
3295 0 0 0 0 0 0 0 0
1 0 ...
3296 0 0 0 0 0 0 0 0
1 0 ...
3297 0 0 0 0 1 0 0 0
0 0 ...
... ... ... ... ... ... .. ... ...
... ... ...
9739 0 0 0 0 0 0 0 0
0 0 ...
9740 0 0 0 0 0 0 0 0
0 0 ...
9741 0 0 0 0 0 0 0 0
190 Machine Learning dengan Python

0 0 ...
9742 0 0 0 0 0 0 1 0
0 0 ...
9743 0 0 0 0 0 0 0 0
0 0 ...

hammond sulk startx iu acceller glxgear cack

stil kdm xserver
3293 0 0 0 0 0 0
0 0 0 0
3294 0 0 0 0 0 0
0 0 0 0
3295 0 0 0 0 0 0
0 0 0 0
3296 0 0 0 0 0 0
0 0 0 0
3297 0 0 0 0 0 0
0 0 0 0
... ... ... ... .. ... ...
... ... ... ...
9739 0 0 0 0 0 0
0 0 0 0
9740 0 0 0 0 0 0
0 0 0 0
9741 0 0 0 0 0 0
0 0 0 0
9742 1 1 0 0 0 0
0 0 0 0
9743 0 0 1 1 1 1
1 1 1 1
[6451 rows x 27220 columns]>
 Natural Language Process (NLP): Machine Learning untuk Data Teks 191

# Sekarang akan kita hitung probabilitas bayes, seperti pada rumus yang di atas.
# Agar probabilitas masing-masing kata tidak nol maka jumlah tiap token harus ditambah alpha.
alpha=1
prob_spam=token_vek.iloc[indeks_spam].sum()+alpha
prob_spam=prob_spam/prob_spam.sum()
prob_spam
Luaran:
save 0.001555
life 0.001489
insur 0.000854
spend 0.000374
quot 0.000716
...
glxgear 0.000003
cack 0.000003
stil 0.000003
kdm 0.000003
xserver 0.000003
Length: 27220, dtype: float64

prob_nonspam=token_vek.iloc[indeks_nonspam].
sum()+alpha
prob_nonspam=prob_nonspam/prob_nonspam.sum()
prob_nonspam
Luaran:
save 0.000418
life 0.000561
insur 0.000068
spend 0.000288
192 Machine Learning dengan Python

quot 0.000380
...
glxgear 0.000004
cack 0.000004
stil 0.000004
kdm 0.000004
xserver 0.000004
Length: 27220, dtype: float64

# Nah, sekarang buatlah fungsi untuk menghitung prob bayes untuk sebuah kalimat def
hitung_bayes(kalimat,prob):
# Bersihkan dulu:

list_token=praproses(kalimat)
p=1
for kata in list_token:
try:
p *=prob[kata]
except:
pass #print(‘Tidak ada dikamus:’,kata )
return p

# Bisa juga hitung bayes dengan skala log:

from math import log, exp

def hitung_bayes_log(kalimat,prob):

# Bersihkan dulu:

list_token=praproses(kalimat)
p=0
for kata in list_token:
 Natural Language Process (NLP): Machine Learning untuk Data Teks 193

try:
p +=log(prob[kata])
except:
pass #print(‘Tidak ada dikamus:’,kata )
return p

# Test fungsi tersebut di atas:

new_email=’Please, send me a credit card!’

hitung_bayes(new_email,prob_spam)
Luaran:
2.5893487593675316e-11

# Sekarang selidiki apakah e-mail itu spam atau non-spam.

p_as_spam=klasifikasi_vek.value_counts()[1]/klasifikasi_
vek.value_counts().sum()*hitung_bayes(new_email,prob_
spam)
p_as_nonspam=klasifikasi_vek.value_counts()[0]/
klasifikasi_vek.value_counts().sum()*hitung_bayes(new_
email,prob_nonspam)

print(f’Kesimpulan:\n p(spam) ={p_as_spam} sementara

p(nonspam) ={p_as_nonspam}’)
if (p_as_spam>p_as_nonspam):
print(‘Email adalah SPAM’)
elif (p_as_spam<p_as_nonspam):
print(‘Email adalah NONSPAM’)
else:
print(‘SPAM/NONSPAM sama kebolehkjadiannya’)
Luaran:
Kesimpulan:
p(spam) =8.750744524422498e-12 sementara p(nonspam)
194 Machine Learning dengan Python

=2.953381126101875e-14
Email adalah SPAM

# Sekarang selidiki apakah e-mail itu spam atau non-spam dengan skala log.

p_as_spam=log(klasifikasi_vek.value_counts()[1]/
klasifikasi_vek.value_counts().sum())+hitung_bayes_
log(new_email,prob_spam)
p_as_nonspam=log(klasifikasi_vek.value_counts()[0]/
klasifikasi_vek.value_counts().sum())+hitung_bayes_
log(new_email,prob_nonspam)
print(f’Kesimpulan:\n log (p(spam)) ={p_as_spam}
sementara log(p(nonspam)) ={p_as_nonspam}’)
if (p_as_spam>p_as_nonspam):
print(‘Email adalah SPAM’)
elif (p_as_spam<p_as_nonspam):
print(‘Email adalah NONSPAM’)
else:
print(‘SPAM/NONSPAM sama kebolehkjadiannya’)

Luaran:
Kesimpulan:
log (p(spam)) =-25.461882330673422 sementara
log(p(nonspam)) =-31.15324064344569
Email adalah SPAM

“””## MENYIMPAN HASIL”””

# Kita akan simpan hasil analisis ke sebuah file.

# Yang akan kita simpan adalah prob_spam, prob_nonspam, dan probabilitas awal
masing-masing.
p_pre_spam=klasifikasi_vek.value_counts()[1]/
 Natural Language Process (NLP): Machine Learning untuk Data Teks 195

klasifikasi_vek.value_counts().sum()
p_pre_nonspam=klasifikasi_vek.value_counts()[0]/
klasifikasi_vek.value_counts().sum()

HASIL=pd.DataFrame(prob_nonspam,columns=[‘NONSPAM’])
HASIL[‘SPAM’]=prob_spam
d=pd.DataFrame({‘NONSPAM’:p_pre_nonspam,’SPAM’:p_pre_
spam},index=[‘pre_prob’])
HASIL=HASIL.append(d)
HASIL
Luaran:

NONSPAM SPAM
save 0.000418 0.001555
life 0.000561 0.001489
insur 0.000068 0.000854
spend 0.000288 0.000374
quot 0.000380 0.000716
... ... ...
cack 0.000004 0.000003
stil 0.000004 0.000003
kdm 0.000004 0.000003
xserver 0.000004 0.000003
pre_prob 0.662048 0.337952
27221 rows × 2 columns
HASIL.columns[0]
Luaran:
‘NONSPAM’
196 Machine Learning dengan Python

# Kita buat sebuah fungsi prediksi yang mengambil data dari DataFrame HASIL def
prediksi_binari(email, data):
p0=hitung_bayes(email,data[data.columns[0]])*data.
loc[‘pre_prob’][0]
p1=hitung_bayes(email,data[data.columns[1]])*data.
loc[‘pre_prob’][1]
if p1>p0:
return data.columns[1]
else:
return data.columns[0]
prediksi_binari(‘This is only credit’, HASIL)
Luaran:
‘SPAM’

# Sekarang simpan HASIL ke hasil_analisa_spam_nonspam.csv.

HASIL.to_csv(‘hasil_analisa_spam_nonspam.csv’)

# Bacalah file hasil analisis dan lakukan prediksi:

hasil_analisa=pd.read_csv(‘hasil_analisa_spam_nonspam.
csv’)
hasil_analisa
Luaran:
Unnamed: 0 NONSPAM SPAM
0 save 0.000418 0.001555
1 life 0.000561 0.001489
2 insur 0.000068 0.000854
3 spend 0.000288 0.000374
4 quot 0.000380 0.000716
... ... ... ...
27216 cack 0.000004 0.000003
27217 stil 0.000004 0.000003
 Natural Language Process (NLP): Machine Learning untuk Data Teks 197

27218 kdm 0.000004 0.000003

27219 xserver 0.000004 0.000003
27220 pre_prob 0.662048 0.337952
27221 rows × 3 columns

# Ubah index dulu:

new_columns = hasil_analisa.columns.values
new_columns[0] = ‘VOKAB’
hasil_analisa.columns = new_columns
hasil_analisa=hasil_analisa.set_index(‘VOKAB’)
hasil_analisa
Luaran:

NONSPAM SPAM
VOKAB
save 0.000418 0.001555
life 0.000561 0.001489
insur 0.000068 0.000854
spend 0.000288 0.000374
quot 0.000380 0.000716
... ... ...
cack 0.000004 0.000003
stil 0.000004 0.000003
kdm 0.000004 0.000003
xserver 0.000004 0.000003
pre_prob 0.662048 0.337952
27221 rows × 2 columns
198 Machine Learning dengan Python

prediksi_binari(‘This is only credit’, hasil_

analisa)
Luaran:
‘SPAM’

“””## KLASIFIKASI NAIVE BAYES SKLEARN”””

# Sekarang kita panggil Classifier Naive Bayes dari sklearn:

from sklearn.naive_bayes import MultinomialNB

# Cara membuat vektor untuk new_email dengan sklearn, diperlukan:

from sklearn.feature_extraction.text import

CountVectorizer

# Untuk memisah data secara random diperlukan:

from sklearn.model_selection import train_test_split

“””### Vektorizer Sklearn, split data, fit MultinomialNB, dan prediksi:”””

# token_vek dapat dibuat dengan CountVectorizer, tetapi hasil bisa beda karena cara
pembersihan beda:

# vektorisasi=CountVectorizer(stop_words=kata_stop_en)
vektorisasi=CountVectorizer()
token_vek_sklearn=vektorisasi.fit_transform(email_vek)
email_vek
Luaran:
0 save life insur spend life quot save g famili
...
1 fight risk cancer http slim guarante lose lbs
...
2 fight risk cancer http slim guarante lose lbs
 Natural Language Process (NLP): Machine Learning untuk Data Teks 199

...
3 adult club offer free membership instant
acces...
4 thought might like slim guarante lose lbs day
...
...
9739 http bizarr collect stuf anim could fetch
sold...
9740 care use one also realli cute thing japanes
av...
9741 sm skip montanaro write jeremi put anoth way
i...
9742 mark hammond like given zodb sound attract
wou...
9743 hi probabl use whatsoev also problem regard
nv...
Name: EMAIL, Length: 9744, dtype: object

token_vek_sklearn

# Data dipisah menjadi dua, yaitu train dan test, dengan ukuran test_size=0.1, artinya 10
persen dipakai untuk test.
# Ini pakai CountVectorizer:

X_train_sk, X_test_sk, y_train_sk, y_test_sk = train_

test_split(token_vek_sklearn,klasifikasi_vek, test_
size=0.4, random_state=22)

# Sekarang kita hitung fit dari data train:

model_sk = MultinomialNB().fit(X_train_sk, y_train_sk)

# Coba lihat, apakah prediksinya benar?

prediksi_sk=model_sk.predict(X_test_sk)
200 Machine Learning dengan Python

prediksi_sk
Luaran:
array([0, 1, 0, ..., 1, 1, 0], dtype=int64)

prediksi_sk==y_test_sk
Luaran:
5490 True
1516 True
9436 True
7944 True
5817 True
...
5576 True
2360 True
1360 True
2236 True
4910 True
Name: KLASIFIKASI, Length: 3898, dtype: bool

“””### Vektorisasi sendiri, split data, fit MultinomialNB dan prediksi:”””

# Kita sudah membuat vektor di atas, yaitu token_vek yang akan dipakai di sini.

token_vek.head()

Luaran:

# Data dipisah menjadi dua, yaitu train dan test, dengan ukuran test_size=0.1, artinya 10
persen dipakai untuk test.
# Ini dengan token_vek membuat sendiri:
 Natural Language Process (NLP): Machine Learning untuk Data Teks 201

X_train, X_test, y_train, y_test =train_test_

split(token_vek,klasifikasi_vek,test_size=0.4,random_
state=22)

# Sekarang kita hitung fit dari data train:

model = MultinomialNB().fit(X_train, y_train)

# Coba lihat, apakah prediksinya benar?

prediksi=model.predict(X_test)
prediksi
array([0, 1, 0, ..., 1, 1, 0], dtype=int64)

prediksi_sk==y_test_sk
Luaran:
5490 True
1516 True
9436 True
7944 True
5817 True
...
5576 True
2360 True
1360 True
2236 True
4910 True
Name: KLASIFIKASI, Length: 3898, dtype: bool

prediksi==y_test
5490 True
1516 True
202 Machine Learning dengan Python

9436 True
7944 True
5817 True
...
5576 True
2360 True
1360 True
2236 True
4910 True
Name: KLASIFIKASI, Length: 3898, dtype: bool

pd.DataFrame({‘Dng vek Sklearn’: prediksi_sk==y_test_

sk, ‘vek sendiri’:prediksi==y_test})
Luaran:
Dng vek Sklearn vek sendiri
5490 True True
1516 True True
9436 True True
7944 True True
5817 True True
... ... ...
5576 True True
2360 True True
1360 True True
2236 True True
4910 True True
3898 rows × 2 columns
 Natural Language Process (NLP): Machine Learning untuk Data Teks 203

“””## Cara membuat vektor tanpa Sklearn”””

# Nah, sekarang buatlah fungsi untuk membuat vektor untuk e-mail baru.
# Urutan katanya sesuai dengan vokab_vek, jika kata tidak ada di vokab_vek
# maka kata tersebut tidak dimasukkan ke vektor

def new_vektor(pesan, vokab):

token=praproses(pesan)
vek=[0]*len(vokab)
for kata in token:
if kata in vokab.values:
vek[vokab_vek[vokab_vek.values==kata].
index[0]]+=1
return [vek]

# Coba copy paste sebuah lagu bahasa Inggris di sini:

new_email1=”””And we would love you to join us for a

bite
Join us for a bite
Join us for a bite
And we would love you to join us for a bite
Join us for a bite
Join us for a bite
And we would love you to join us for a bite
Join us for a bite
Can’t wait to meet you
So join the animatronic family
We open real soon
Try your best to hold on to sanity
Come get to know me
And you won’t want to leave after tonight
Down here we’re lonely
204 Machine Learning dengan Python

And we would love you to join us for a bite

You’ve been through twenty long, frightful nights
You’ve seen their faces, felt all their bites
You know our show is so far from over
And Freddy told us you’re an organ donor
All eyes are on you
We can walk you through our dark fantasy
Learn what we’ve gone through
We can teach you to laugh at tragedy
You’ve…”””

new_email_vek1=new_vektor(new_email1,vokab_vek)
model.predict(new_email_vek1)==EMAIL_NONSPAM

# Sekarang copy_paste tentang credit card

# Misal dari sini: https://www.discover.com/credit-
cards/resources/7-tips-for-applying-for-your-first-
credit-card/
new_email2=”””
When you’re just beginning to build your credit, look
into cards that require
little or no credit history. The best first-time credit
card for you may be a
secured card or student credit card. With secured
cards, your credit line will
equal the amount of the required one-time cash deposit
after you are approved.
The difference between this and a debit card is that
your on-time payments help
establish a credit history.
 Natural Language Process (NLP): Machine Learning untuk Data Teks 205

Also consider a student credit card with a low annual

percentage rate (APR) and
a rewards program. You could earn cash back on
purchases that will come in handy
when it’s time to buy books.
“””
new_email_vek2=new_vektor(new_email2,vokab_vek)
model.predict(new_email_vek2)==EMAIL_NONSPAM
# Bandingkan dengan program buatan sendiri:
prediksi_binari(new_email2,HASIL)
Luaran:
‘SPAM’

# Cara membuat vektor dari new_email dengan sklearn:

new_email_vek_sklearn=vektorisasi.transform([new_
email1, new_email2]).toarray()
model_sk.predict(new_email_vek_sklearn)

“””## Simpan Data untuk diproses dengan Sklearn”””

# Simpan data yang dipakai oleh sklearn, yaitu: email_vek, klasifikasi_vek, dan hasil
analisis di dalam model_sk.
# email_vek dan klasifikasi_vek digabung saja:

DATA_SK=pd.DataFrame(email_vek)
DATA_SK[‘KLASIFIKASI’]=klasifikasi_vek
DATA_SK
Luaran:
206 Machine Learning dengan Python

EMAIL KLASIFIKASI
save life insur spend life quot save g
0 1
famili ...
fight risk cancer http slim guarante lose
1 1
lbs ...
fight risk cancer http slim guarante lose
2 1
lbs ...
adult club offer free membership instant
3 1
acces...
thought might like slim guarante lose
4 1
lbs day ...
... ... ...
http bizarr collect stuf anim could
9739 0
fetch sold...
care use one also realli cute thing
9740 0
japanes av...
sm skip montanaro write jeremi put anoth
9741 0
way i...
mark hammond like given zodb sound
9742 0
attract wou...
hi probabl use whatsoev also problem
9743 0
regard nv...
9744 rows × 2 columns

# Cek lagi apakah ada yang string-nya nol setelah pembersihan?

(DATA_SK.EMAIL.str.len()==0).any()
Luaran:
True
 Natural Language Process (NLP): Machine Learning untuk Data Teks 207

# Hapus saja yang tidak ada string-nya:

hapus=DATA_SK[DATA_SK.EMAIL.str.len()==0].index
DATA_SK.drop(hapus, inplace=True)
DATA_SK.reset_index(inplace=True)

# Simpan data ke file:

DATA_SK.to_csv(r’DATA_spam_nonspam_
sk.csv’,index=False)

# Simpan hasil ke file pkl dengan pickle:

import pickle
with open(r’HASIL_spam_nonspam_sk.pkl’, ‘wb’) as file:
pickle.dump(model_sk, file)
model_sk.coef_
Luaran:
array([[-11.19732391, -11.19732391, -7.05101961, ...,
-12.11361464,-12.11361464, -12.11361464]])
model_sk.intercept_
Luaran:
array([-1.09741561])
208 Machine Learning dengan Python

DAFTAR PUSTAKA
Beysolow II, T. 2018. Applied Natural Language Processing with Python Implementing Machine
Learning and Deep Learning Algorithms for Natural Language Processing. In Applied
Natural Language Processing with Python.
Dönmez, P. 2013. Introduction to Machine Learning. In A. Ethem (Ed.), Natural Language
Engineering (Vol. 19, Issue 2). https://doi.org/10.1017/s1351324912000290.
Fadlilah, U., Mahamad, A. K., & Handaga, B. 2021. The Development of Android for Indonesian
Sign Language Using Tensorflow Lite and CNN: An Initial Study. Journal of Physics:
Conference Series, 1858 (1). https://doi.org/10.1088/1742-6596/1858/1/012085.
Hinton, M. 2020. Corpus Linguistics Methods in the Study of (Meta) Argumentation.
Argumentation, 0123456789. https://doi.org/10.1007/s10503-020-09533-z.
Lane, H., Howard, C., & Hapke, H. M. 2019. Natural Language Processing in Action
(Understanding, Analyzing, and Generating Text with Python). Manning.
Severance, C. 2015. Guido van Rossum: The Early Years of Python. Computing Convertions,
48 (2), 7–9. https://doi.org/10.1109/MC.2015.45.
Thivaharan, S., Srivatsun, G., & Sarathambekai, S. 2020. A Survey on Python Libraries
Used for Social Media Content Scraping. Proceedings - International Conference on
Smart Electronics and Communication, ICOSEC 2020, July 2021, 361–366. https://doi.
org/10.1109/ICOSEC49089.2020.9215357.
BAB 4
PENGANTAR SUPPORT VECTOR
MACHINE (SVM)

4.1. Pendahuluan
Metode Support Vector Machine (SVM) merupakan metode klasifikasi yang lebih umum dari
yang sudah kita kenal di mana metode ini memaksimalkan margin, yaitu ruang yang tidak
memuat data yang berbeda. Hal ini menjadi tidak mudah karena data tidak selalu terpisah
linear, jadi pemisah antara kelompok data yang serupa tidak bisa garis linear saja jika data
pada bidang atau bidang datar data pada ruang 3 dimensi. Jika data pada n-dimensi (yang
berarti memuat banyak faktor) maka bidang datar pemisah disebut hyperplane. Jadi, SVM
akan mengklasifikasi data dengan batas antarkelas yang tidak selalu linear. Pada bagian
berikut ini, ditunjukkan prinsip dasar SVM secara bertahap, dimulai dari data pada bidang
datar agar teori dapat diikuti. Bagian buku ini mengulas SVM yang sebagian besar mengikuti
literatur (Kowalczyk, 2017).

4.1.1. Tujuan SVM

Tujuan Support Vector Machine (SVM) adalah mencari bidang (hyperplane) pemisah optimal
yang memaksimalkan margin dari data latih. Jadi dari tujuan ini, SVM memerlukan data latih
yang berarti SVM merupakan algoritma pembelajaran terbimbing menurut pembelajaran
mesin. SVM merupakan algoritma untuk mengklasifikasi yang berarti menggolongkan data
pada suatu kelas tertentu.
210 Machine Learning dengan Python

Gambar 4.1 Ilustrasi data berlabel

Gambar 4.1 merupakan tinggi dan berat beberapa orang dari laki-laki dan perempuan.
Dengan himpunan data tersebut, selanjutnya, SVM akan membantu menjawab pertanyaan:
jika ada data berat dan tinggi, apakah orang itu laki-laki atau perempuan? Misal, jika seseorang
dengan ukuran tinggi 175 cm dan berat 80 cm apakah dia laki-laki atau perempuan?

4.1.2. Apakah Bidang (Hyperplane) Pemisah?

Kita dapat melihat data pada gambar bahwa terjadi 2 kelompok yang berbeda, misalkan kita
akan memasangkan garis yang memisahkan laki-laki dan perempuan maka garis (hyperplane)
tersebut disebut garis (hyperplane) pemisah.
 Pengantar Support Vector Machine (SVM) 211

Gambar 4.2 Ilustrasi contoh garis pemisah yang mungkin

Dari Gambar 4.2, terdapat 3 garis (bisa lebih) yang memungkinkan untuk merupakan
pemisah 2 kelompok. Pertanyaan yang muncul: manakah yang terbaik?

4.1.3. Mengapa Diberi Nama Hyperplane?

Pada gambar, data memang hanya informasi yang dibangun dari pasangan data dalam 2
dimensi. Akan tetapi, SVM dapat digunakan pada ruang Rn. Kata hyperplane merupakan
generalisasi dari suatu bidang. Dalam 1 dimensi, suatu hyperplane adalah titik. Dalam 2
dimensi, hyperplane adalah garis; dalam 3 dimensi hyperplane adalah bidang; dan dimensi
lebih dari 3 disebut hyperplane.
212 Machine Learning dengan Python

4.1.4. Apakah Margin dalam SVM Menentukan Optimal Hyperplane yang

Terbaik?
Diberikan suatu margin maka diharapkan tidak ada data dalam margin tersebut. Hal ini
sebenarnya sukar terjadi karena dapat terjadi data memuat informasi yang tidak jelas (noise
data) tetapi hal inilah yang dikehendaki bahwa dengan adanya margin memberikan batas
keterpisahan 2 kelompok data.

Gambar 4.3 Ilustrasi margin

 Pengantar Support Vector Machine (SVM) 213

4.1.5. Margin A Lebih Besar daripada Margin B

Dari pengamatan dapat disimpulkan:
Jika suatu hyperplane sangat dekat pada suatu data maka margin akan kecil. Semakin jauh
suatu hyperplane dari data maka margin makin besar. Hal inilah yang menyebabkan tujuan
SVM adalah memilih hyperplane pemisah optimal yang memaksimalkan margin data latih.

4.1.6. Bagaimana Menghitung Margin?

Dalam kata SVM ada kata vektor. Hal ini berarti perlu dipahami dengan benar, kata vektor dan
hal-hal yang terkait dengan vektor, seperti: norm, arah, penambahan dan pengurangan vektor,
perkalian dot, dan proyeksi vektor pada vektor yang lain. Setelah itu perlu ditanyakan: apakah
persamaan untuk hyperplane dan bagaimana menghitung margin?
Contoh 4.1

Gambar 4.4 Contoh penampilan vektor dari O ke A(3,4)

Perhatikan titik A(3,4) di R2. Jika kita tarik garis dari O(0,0) pada titik tersebut maka kita
dapat mendefinisikan vektor OA, di mana garis dari O ke-A merupakan vektor tersebut. Jadi
vektor adalah objek yang mempunyai arah dan besaran, sedangkan panjang garis dari O
ke A disebut panjang vektor yang disebut norm vektor atau disebut panjang segment OA.
Ditulis panjang segmen OA dengan ||OA|| di mana kita dapat menghitungnya dengan rumus
Pythagoras, sedangkan arah vektor ditunjukkan dengan vektor satuan.
Coding untuk hal ini secara sederhana sebagai berikut:
import numpy as np x = [3,4]
np.linalg.norm(x) # 5.0
214 Machine Learning dengan Python

Dengan menjalankan perintah tersebut diperoleh 5.

Jika sembarang vektor adalah u = [u1,u2]T maka vektor satuan u = [u1,u2]T adalah

T
 u u 
e 1 , 2  .
  u ,  u , 

Gambar 4.5 Ilustrasi vektor u dengan sudut yang dibentuk

Bagaimana arah vektor didefinisikan? Kita ketahui bahwa vektor pada 2 dimensi tersebut
membentuk 2 sudut, yaitu sudut terhadap sumbu horizontal dan sudut terhadap sumbu vertikal.
Oleh karena itu, vektor arah ditentukan oleh arah vektor u = [u1,u2]T terhadap sumbu x dan
sumbu y yang didefinisikan sebagai

u1 u2
cos( )  : cos( ) 
u u

Kita dapat menuliskan pada Python sebagai berikut:

import numpy as np # Hitung arah x.

def arrah(x):
return x/np.linalg.norm(x)
 Pengantar Support Vector Machine (SVM) 215

Gambar 4.6 Sudut yang dibentuk antara 2 vektor

Tetapi diketahui bahwa

cos   = cos       cos    cos    sin    sin  

x1 y1 x2 y 2
cos    
 x  y   x  y 
x1 y1  x2 y 2 x. y
cos    
 x  y   x  y 

Jika dikalikan kedua ruas dengan ||x||||y|| diperoleh:

cos    x  y  x1 y1  x2 y 2

Yang sama artinya dengan:

 x  y  cos    x. y

Selanjutnya, pahami tentang penjumlahan dan pengurangan antara 2 vektor secara geometri.
Anggaplah 2 hal terebut telah diketahui, kita tinggal mempelajari proyeksi ortogonal vektor.
216 Machine Learning dengan Python

4.1.7. Proyeksi Ortogonal Suatu Vektor

Gambar 4.7 Sudut yang dibentuk antara 2 vektor dan vektor yang diproyeksikan

Anggaplah vektor x diproyeksikan ortogonal ke vektor y (pada Gambar 4.7) maka diperoleh
vektor proyeksi searah y dan sebutlah z. Dari Gambar 4.6 diperoleh hubungan

z
cos   
x
Yang berarti pula

 z  x  cos  

Gambar 4.8 Hubungan vektor yang diproyeksikan dan proyeksinya

 Pengantar Support Vector Machine (SVM) 217

Dari hasil di atas dengan pengetahuan sebelumnya diperoleh:

x. y
cos    dan karena
 x  y 

 z  x  cos  

Diperoleh
x. y x. y
 z  x  
 x  y   y 

Padahal
y
u sehingga  z  u. x
 y

Perhatikan bahwa z searah dengan y sehingga

z
u sehingga z  u  z 
z

Substitusikan  z  u. x pada z  u  z  diperoleh z   u. x  u

Jadi kita dapat menuliskan z = (u . x) u di mana z adalah vektor proyeksi ortogonal x ke y.

Gambar 4.9 Ilustrasi selisih antara 2 vektor

218 Machine Learning dengan Python

Dengan mengetahui hal itu kita dapat menghitung jarak vektor x dan z, yaitu dibentuk dari
panjang vektor x -z. Jadi diperoleh:

Dengan coding Python kita dapat mencari arah vektor sebagai berikut:
u_1 = np.array([3,4])
u_2 = np.array([30,40])
print(arah(u_1)) # [0.6 , 0.8]
print(arah(u_2)) # [0.6 , 0.8]

np.linalg.norm(np.array([0.6, 0.8])) # 1.0

Berikut ini bagaimana kita menghitung dot.product dengan Python:

def dot_product(x,y):
hasil = 0 for i in range(len(x)):
hasil = hasil + x[i]*y[i] return hasil

x = [3,5]
y = [8,2]
print(dot_product(x,y)) # 34

4.2. Bagaimana SVM Dibuat?

Kita mengetahui persamaan garis, yaitu y=ax +b, sedangkan jika dalam hyperplane maka
persamaan umum bidang adalah
wTx = 0.

Kita tahu bahwa y=ax +b dapat ditulis y-ax -b = 0. Atau dapat ditulis:

y*1+(−a)*x+(−b)*1=0.
 Pengantar Support Vector Machine (SVM) 219

 b   1
   
Persamaan tersebut dapat ditulis dalam notasi vektor. Sebutlah 2 vektor w   a  dan x   x 
 1   y 

wT x  bx 1   a  x x   b  x1  0

wT x  y  ax  b

Yang menjadi masalah, mengapa menggunakan notasi tersebut? Karena kita akan tahu
bahwa vektor w adalah vektor yang selalu merupakan vektor normal ke hyperplane di mana
di sini kita selalu mendefinisikan w0 =0. Pada Gambar 4.10, kita mempunyai hyperplane yang
memisahkan 2 grup data di mana persamaannya adalah:
x2=2x1

wT x  0
Contoh 4.2

Gambar 4.10 Ilustrasi pemisahan data dengan SVM

220 Machine Learning dengan Python

2  x1 
Di mana w=   ,x=  
 1  x2 

Catat bahwa vektor w ditunjukkan pada Gambar 4.10 tersebut di mana w bukan data. Kita akan
menghitung jarak titik A(3,4) dan hyperplane. Jarak dari A dan proyeksinya pada hyperplane:

Gambar 4.11 Ilustrasi pemisahan data dengan SVM lanjutan

Kita tahu bahwa kita dapat menyusun vektor dari A ke titik O. Kita dapat memproyeksikan A
normal ke vektor w sebagaimana pada Gambar 4.12.

Gambar 4.12 Ilustrasi pemisahan data dengan vektor yang diproyeksikan serta hyperplane yang
diperoleh
 Pengantar Support Vector Machine (SVM) 221

Hasilnya diperoleh vektor p.

Gambar 4.13 Ilustrasi pemisahan data dengan vektor yang diproyeksikan serta hyperplane yang
diperoleh dan vektor hasil proyeksi

Tujuan kita adalah menghitung jarak dari titik A ke hyperplane. Jarak itu adalah panjang vektor
p, yaitu ||p||.
Kita tahu bahwa w= [2,1]T adalah vektor normal ke hyperplane dan a=[3,4] T adalah vektor dari
O ke titik A.
Sebutlah vektor u adalah vektor arah w, dan p adalah proyek a pada w sehingga
T
 2 1 
 w  4  1  5 dan vektor satuannya adalah u   ,  .
 5 5

Jelas bahwa dari formulasi z   u. x  u kita dapat menyusun

T
2 1  2 1 
p   u.a  u =( 3x  4x ) , 
5 5  5 5

T T
10  2 1   20 10 
p   u.a  u =  ,   , 
5  5 5 5 5
T
p   4,2 dan  p  42  22  2 5 .
222 Machine Learning dengan Python

4.2.1. Hitung Margin Hyperplane

Diketahui bahwa || p || adalah jarak antara A dan hyperplane sehingga margin didefinisikan
sebagai 2||p|| = 4 5 . Bagaimana menghitung hyperplane optimal? Pada bagian lalu, kita
sudah menghitung panjang ||p||, tetapi ternyata masih dianggap tidak optimal.

Gambar 4.14 Yang menyediakan hyperplane

Diketahui bahwa hyperplane yang maksimal adalah hyperplane yang memaksimalkan

margin dari data latih. Pada gambar semula, diketahui margin dan sebutlah M1, tetapi M1
bukanlah margin terbesar yang memisahkan data terbaik. Margin terbesar adalah M2 pada
Gambar 4.15.
 Pengantar Support Vector Machine (SVM) 223

Gambar 4.15 Ilustrasi hyperplane

Bagaimana mendapatkan hyperplane terbaik:

1. Pilih himpunan data.
2. Pilih 2 hyperplane yang memisahkan data dengan tidak yang ada titik-titik di antaranya.
3. Maksimalkan jarak (marginnya).
Daerah yang dibatasi oleh 2 hyperplane merupakan margin terbesar. Jikalau demikian
mudah maka SVM dianggap sulit oleh para pengguna. Hal ini dikarenakan diperlukan
pemahaman matematika yang baik.
Step 1. Kita mempunyai suatu himpunan data D dan kita ingin melakukan klasifikasi. Data
kita terdiri dari vektor xi. Setiap xi berasosiasi dengan nilai yi yang mengindikasikan bahwa jika
elemen-elemennya tergolong kelas maka bertanda +1 dan sebaliknya akan bertanda -1. Jadi
nilai yi hanya bernilai +1 atau -1.
Step 2. Kita ingin membuat hyperplane yang memisahkan data sehingga ruang di antara
hyperplane tidak memuat titik.
Untuk data pada bidang 2 dimensi maka kita dapat menggambar dengan pensil. Akan
tetapi, pada umumnya, data berdimensi p sehingga tidak mungkin digambar. Sekalipun
demikian, kita tidak dapat selalu menemukan hyperplane untuk memisahkan data dalam 2
dimensi. Hal ini hanya bisa dilakukan jika data terpisah secara linear.
224 Machine Learning dengan Python

Gambar 4.16 Data terpisah linear (kiri) dan terpisah tidak linear (kanan)

Jadi kita mengasumsikan bahwa data D terpisah secara linear. Kita ingin mengetahui
bagaimana 2 hyperplane tanpa ada titik di antaranya, tetapi kita tidak dapat memvisualisasikan.
Kita tahu bahwa persamaan hyperplane adalah wTx = 0.
Tetapi Wikipedia menuliskan berbeda, yaitu sebarang hyperplane dapat ditulis w.x +b =0.
Kita mengetahui bahwa penulisan dengan dot product digunakan w.x sebagai wTx.
Pertanyaannya bagaimana notasi b muncul?
Dalam tulisan ini, w dan x dalam 3 dimensi, sedangkan dalam Wikipedia menuliskannya dalam
2 dimensi.
Diberikan vektor 3 dimensi, yaitu w=[b,-a,1]T dan x=[1,x,y]T

w. x = b x (1) + (-a) x x +1 x y

w.x = y- ax +b (4.1)

Misalkan diberikan vektor 2 dimensi w’=[-a,1]T dan x’=[x,y]T sehingga

w’. x’=(-a x x) +(1xy)

w’. x’ = y-ax (4.2)

Jika kita tambahkan b pada kedua ruas maka diperoleh

w’. x’+ b = y-ax +b (4.3)

= w. x
 Pengantar Support Vector Machine (SVM) 225

Jadi, pada diskusi selanjutnya kita akan menggunakan notasi w.x + b = 0.

Kita dapat memilih hyperplane H1 dan H2 yang memisahkan data dengan persamaan berikut
ini:

w.x + b = α

dan

w.x + b = -α

Sehingga Ho mempunyai jarak yang sama dengan H1 dan H2. Akan tetapi, variabel α tidak
perlu sehingga kita bisa memilih α =1 untuk menyederhanakan masalah w.x + b = 1 dan w.x
+ b = -1.
Akan ditunjukkan bahwa tidak ada titik di antara hyperplane tersebut. Untuk setiap vektor xi
berlaku
w.x + b ≥ 1 untuk xi berada pada kelas 1 (4.4)
atau

w.x + b ≤ -1 untuk xi berada pada kelas -1. (4.5)

Kita akan memahami kendala dengan memperhatikan Gambar 4.17.

Gambar 4.17 Ilustrasi w.x-b=-1 dan w.x-b =1

226 Machine Learning dengan Python

Pada Gambar 4.17, semua titik bertanda bintang berada pada kelas 1 dan yang bertanda
bulat berada pada kelas -1. Yang perlu dibuktikan tidak melanggar kendala w.x + b ≥ 1.
Ketika xi =A, kita dapat melihat titik pada bidang hyperplane w.xi + b =1 dan kendala dipenuhi.
Demikian pula pada B, ketika xi =C, kita dapat melihat bahwa titik di atas pada bidang dengan
kondisi kendala w.x + b > 1 dan kendala dipenuhi. Demikian pula titik D, E, F, dan G. Dengan
analogi yang sama, kita dapat membawa kendala ke-2 terkait dengan kelas -1.
Pada Gambar 4.18 kita melihat sepasang hyperplane yang berbeda lagi.

Gambar 4.18 Jenis hyperplane yang berbeda-beda

 Pengantar Support Vector Machine (SVM) 227

Kita akan mempelajari bidang hyperplane di mana kondisi tidak dipenuhi menurut Gambar
4.19.

Gambar 4.19 Jenis hyperplane yang tidak benar

Apa yang dimaksud jika kendala tidak dipenuhi?

Artinya, kita tidak dapat memilih dua hyperplane tersebut. Kita melihat bahwa setiap waktu
kendala tidak dipenuhi, terdapat titik-titik berada di antara 2 hyperplane. Dengan menggunakan
definisi kendala ini, kita menemukan cara untuk mencapai tujuan mula-mula, yaitu pemilihan
hyperplane yang berlaku juga pada dimensi-p.
Kita mulai dari persamaan atau w.x + b ≤ -1 untuk xi berada pada kelas -1.
Kedua ruas dikalikan dengan yi (yang selalu bernilai -1 pada kasus ini) sehingga diperoleh

yi (w.x + b) ≥ yi (-1) untuk xi berada pada kelas -1. Pada persamaan (4.5)

berarti selalu dapat ditulis

yi (w.x + b) ≥ 1 untuk xi berada pada kelas -1 (4.6)

Pada persamaan (4), kedua ruas dikalikan dengan yi (yang selalu bernilai 1 pada kasus ini)
sehingga diperoleh persamaan yang sama

yi (w.x + b) ≥ 1 untuk xi berada pada kelas 1 (4.7)

Jadi dengan menggabungkan keduanya diperoleh

yi (w.x + b) ≥ 1 untuk xi untuk semua 1 ≤ i ≤ n (4.8)

Jadi persamaan (4.8) menunjukkan tidak ada efek pada kedua kendala di mana tidak ada titik
di antara hyperplane.
228 Machine Learning dengan Python

Step 3. Memaksimalkan jarak antara 2 hyperplane.

Ini bagian yang paling sulit, tetapi akan dijelaskan secara terperinci.
Apakah jarak antara 2 hyperplane?
Sebelum dimaksimalkan, tentu kita bertanya bagaimana menghitungnya.
Sebut:
H0 adalah hyperplane yang mempunyai persamaan w.x + b = -1
H1 adalah hyperplane yang mempunyai persamaan w.x + b = 1
xo adalah titik pada bidang H0.
Sebutlah m adalah jarak tegak lurus dari xo pada bidang H1. Berdasarkan definisi, m adalah
yang kita sebut margin. Karena xo adalah titik pada bidang H0, m adalah jarak dari hyperplane
H0 dan H1. Kita akan mencari nilai m.

Gambar 4.20 Ilustrasi margin sepanjang m pada hyperplane

Kita mungkin berkeinginan jika kita menambahkan m pada xo, kita akan mendapatkan
titik yang lain, dan titik ini akan berada pada hyperplane yang lain. Tetapi hal ini tidak mungkin
terjadi karena m adalah skalar dan xo adalah vektor di mana menambahkan vektor dan skalar
tidak mungkin bermakna. Tetapi penambahan 2 vektor dimungkinkan sehingga jika kita
mentransformasi m menjadi suatu vektor akan terjadi penambahan. Kita dapat menemukan
himpunan semua titik-titik yang berjarak m dari xo.
 Pengantar Support Vector Machine (SVM) 229

Gambar 4.21 Ilustrasi margin sepanjang m pada hyperplane dengan jarak yang dimungkinkan

Jadi semua titik akan berjarak sama dengan m adalah titik-titik pada lingkaran dengan
pusat xo sebagaimana ditunjukkan pada Gambar 4.21. Karena kita tidak dapat menambahkan
skalar dan vektor, tetapi kita dapat mengalikan skalar dengan vektor untuk mendapatkan
vektor lain. Jadi kita menghendaki suatu vektor ini:
1. Mempunyai besar m.
2. Tegak lurus pada hyperplane H1.
3. Untungnya, kita mengetahui bahwa vektor yang tegak lurus H1 adalah w (karena H1: w.x
+ b = 1.

Gambar 4.22 Ilustrasi margin sepanjang m antar-hyperplane yang dimungkinkan

230 Machine Learning dengan Python

w
Marilah kita definisikan u  merupakan vektor satuan sehingga ||u|| =1 dan mempunyai
w

arah yang sama dengan w sehingga juga tegak lurus dengan hyperplane yang ditunjukkan
pada Gambar 4.22.

Gambar 4.23 Ilustrasi margin sepanjang m pada hyperplane vektor u yang tegak lurus pada hyperplane

Jika kita kalikan u dengan m maka diperoleh vektor k = m u dan

1. ||k|| =m.
2. k adalah tegak lurus pada H1 (karena punya arah yang sama dengan u).
Oleh karena sifat-sifat ini, kita dapat melihat bahwa k adalah vektor yang kita cari.
 Pengantar Support Vector Machine (SVM) 231

Gambar 4.24 Ilustrasi vektor k sepanjang m yang searah u pada hyperplane yang tegak lurus
pada hyperplane

Jadi
w
k=mu m (9)
w

Kita berhasil mentransformasi skalar m menjadi vektor k yang dapat digunakan sebagai
vektor yang dapat ditambahkan kepada vektor xo. Jika kita mulai dari titik xo dan menambahkan
k, diperoleh vektor yang lain, yaitu zo = xo. + k pada hyperplane H1 sebagaimana ditunjukkan
pada Gambar 4.25.
232 Machine Learning dengan Python

Gambar 4.25 Ilustrasi vektor k, zo = xo. + k dan xo pada hyperplane

Karena zo = xo. + k pada hyperplane H1 yang berarti

w. zo +b =1 (4.10)

Kita dapat menggantikan zo = xo. + k sehingga

w. (xo. + k) +b =1 (4.11)

w
Juga diketahui bahwa k = m u  m sehingga
w

w
w. (xo. + m ) +b =1
w

Diperoleh
w.w
w. xo + m +b = 1
w
 Pengantar Support Vector Machine (SVM) 233

yang ekuivalen dengan

2
w
w. xo + m + b=1
w

Sehingga
w. xo + m ||w|| +b = 1

Diketahui bahwa w. xo +b = -1 karena xo pada Ho sehingga

m ||w|| -1 =1 atau m ||w|| =2 sehingga

m = 2/||w||

Kita telah sampai pada tujuan bahwa diperoleh hasil nilai m.

Sekarang bagaimana memaksimalkan m? Diketahui m = 2/||w|| yang berarti menentukan nilai
maksimum adalah ||w||.
Ingat tujuan kita adalah memaksimalkan margin. Kita akan coba dengan beberapa nilai:
Jika ||w|| =1 maka m =2
Jika ||w|| =2 maka m =1
Jika ||w|| =4 maka m =1/2
Jadi dapat diketahui ketika ||w|| semakin besar maka margin makin kecil. Jadi memaksimalkan
margin sama artinya meminimalkan ||w||. Jadi dari berbagai hyperplane, kita akan memilih
yang meminimalkan ||w|| karena kita menghendaki margin maksimal. Hal ini menjadi masalah
optimasi, yaitu

Minimalkan (w,b), yaitu ||w|| (P.1)

dengan kendala

yi (w. xi + b) ≥1 (untuk sembarang i =1,...,n) (P.2)

Jadi dengan menyelesaikan masalah optimasi tersebut kita dapat menemukan pasangan (w,b)
di mana ||w|| adalah kemungkinan terkecil yang memenuhi kendala dan berarti kita sudah
memperoleh hyperplane yang optimal.
Dilanjutkan dengan pustaka e-book SVM (Kowalczyk, 2017, hal 54-57).
234 Machine Learning dengan Python

4.3. Masalah Optimasi SVM dengan Metode Lagrange

Problem optimasi (P.1) – (P.2) ekuivalen dengan masalah optimasi

minimalkan 1 2
w
w,b 2

dengan kendala

yi (w.xi + b ) -1≥ 1, i=1,...,n

Faktor ½ ditambahkan pada masalah optimasi karena ketika kita akan menyelesaikan optimasi
kuadratik dengan menguadratkan norm maka kita memperoleh keuntungan tanpa menghitung
akar di mana hampir pada semua buku optimasi menggunakan cara ini, sedangkan masalah
yang semula lebih sulit untuk diselesaikan.
Kembali pada masalah utama bahwa kita mempunyai fungsi tujuan yang diminimalkan, yaitu

1 2
f(w) = w
2
dengan kendala

gi(x,b) = yi (w.xi + b ) -1, i=1,...,n

Sehingga kita dapat menyusun fungsi Lagrange:

n
L(w, x,b,α) = f(w) – 
i 1
i g i  w, b 

n
1

2
L(w, x,b,α) = w – i  yi  w. xi  b   1
2 i 1

Masalah Lagrange mempunyai kendala pertidaksamaan dengan n pertidaksamaan di mana

n: banyaknya data latih. Prinsip duality menyatakan bahwa suatu optimasi dapat dipandang
dengan 2 perspektif. Pertama adalah masalah primal, yaitu masalah meminimalkan, sedangkan
dualnya adalah masalah memaksimalkan. Prinsip dualitas menyatakan bahwa maksimum dari
masalah dual akan selalu lebih kecil atau sama dengan minimum dari masalah primalnya
(artinya hal ini menjamin adanya batas bawah dari masalah primal). Pada kasus kita, kita ingin
menyelesaikan masalah optimasi konveks dan kondisi Slater dipenuhi, yaitu maksimum dari
 Pengantar Support Vector Machine (SVM) 235

masalah dual adalah sama dengan minimum dari masalah primal. Selesaikan masalah dual ini
seperti menyelesaikan masalah primal.
Kita panggil fungsi Lagrange:
n
1

2
L(w, x,b,α) = w – i  yi  w. xi  b   1 .
2 i 1

n
1
=
2
w.w – 
i 1
i  yi  w. xi  b   1 .

Jadi pada kasus ini, kita akan menyelesaikan masalah optimasi fungsi konveks (dijamin
adanya peminimum) dan kondisi Slater dipenuhi di mana kondisi Slater menyatakan bahwa
ada masalah dualitas pada kasus ini. Masalah dualitas di sini adalah maksimum dari masalah
dual sama dengan minimum dari masalah primal. Jadi menyelesaikan masalah dual sama
artinya menyelesaikan masalah primal di mana masalah dual lebih mudah.
Ingat fungsi Lagrange yang akan diselesaikan adalah:
n
1

2
L(w, x,b,α) = w – i  y i  w. xi  b   1
2 i 1

n
1
=
2
w.w – 
i 1
i  y i  w. xi  b   1 ] .

Masalah primalnya adalah:

min maks
L w , b, 
w, b 

Di mana:
α i ≥ 0, i=1,...,n

Dengan menurunkan terhadap w dan b diperoleh:

(4.12)
236 Machine Learning dengan Python

Dari persamaan pertama diperoleh:

n
w  y x .
i 1
i i i (4.13)

Dengan menyubstitusikan w pada L diperoleh:

1
n  n 
W  á, b   
2    i y i xi  

 y j j xj 

i 1  j 1 
n   n   
  i yi  
    j y j x j  . xi  b   1 
  
i 1
  j 1   
n n
1

2   y
i 1 j 1
i j i y j xi . x j

n  n   n
  i yi  
   j y j x j  . xi  b  
   i
i 1  j 1   i 1

n n n n n n
1

2 
i 1 j 1
 i  j y i y j xi . x j   i 1 j 1
 i  j y i y j xi . x j  b 
i 1
i yi   i 1
i

n n n n
1
 
i 1
i 
2 
i 1 j 1
 i  j y i y j xi . x j  b  y
i 1
i i

Kita berhasil menyingkirkan w, tetapi b masih ada pada suku terakhir sehingga:
n n n n
1
W(α,b) = 
i 1
i 
2 
i 1 j 1
 i  j y i y j xi . x j  b  yj 1
i i

n
L
Kita tahu bahwa
b
 0 yang berarti bahwa  y
j 1
i i  0 . Jadi suku terakhir sama dengan 0

dan kita dapat menulis:

n n n
1
W(α,b) =  i 1
i 
2  
i 1 j 1
i j y i y j xi . x j

Persamaan ini yang disebut fungsi dual Wolfe Lagrange.

 Pengantar Support Vector Machine (SVM) 237

Masalah optimasi sekarang disebut masalah dual Wolfe:

n n n
maks 1
 
i 1
i 
2  
i 1 j 1
i j y i y j xi . x j (P.2.a)

dengan kendala
n
αi ≥ 0, i =1,...,n dan  y
j 1
i i 0. (P.2.b)

Pada dasarnya, masalah optimasi dual Wolfe tersebut dibatasi oleh gradien sama dengan 0.
Secara teori, kita menambahkan kendala

f
 w L  0 dan 0
b
Akan tetapi, kita hanya akan menambahkannya nanti, sedangkan
n

 y
j 1
i i 0

karena kita menghendaki untuk tidak memunculkan b pada fungsi. Akan tetapi, kita dapat
n
menyelesaikan masalah tersebut tanpa kendala w   y x . Keuntungan utama masalah
i 1
i i i

dual Wolfe adalah masalah Lagrange yang muncul dengan fungsi tujuan W hanya tergantung
pengali Lagrange. Hal ini sangat berguna dalam pembuatan program Python, serta dalam
penyusunan kernel nantinya. Apa yang dimaksud kernel di sini? Kernel adalah fungsi yang
diasumsikan sebagai bentuk pemisah antarkelas yang dapat berupa linear dan dapat berupa
tak linear.
Pelajari berikut ini.
Data yang sedang kita pelajari selama ini masih secara linear terpisah sehingga kita
menggunakan hyperplane. Bagaimana jika data terpisah secara tidak linear seperti pada
gambar berikut.
238 Machine Learning dengan Python

Untuk itu, program perlu disusun untuk dapat digunakan bagi data terpisah secara linear dan
tak linear. Adapun otomatisasi tersebut dilakukan dengan memberikan kernel di mana kernel
adalah fungsi yang dibangun sebagai pemisah data secara linear atau tak linear. Bagaimana
SVM Kernel kerjakan? Bagaimana klasifikasi dilakukan? Kernel SVM memproyeksikan
pemisah data tak linear dengan dimensi rendah menjadi ke pemisah data linear dimensi yang
lebih tinggi. Kernel SVM melakukan klasifikasi dengan cara data dalam klasifikasi yang berbeda
dialokasikan pada dimensi yang berbeda. Untuk memahami bagaimana Python disusun maka
kita perlu mengetahui terlebih dahulu bagaimana SVM dibuat.

4.3.1. Keuntungan Algoritma SVM

Dari literatur, peneliti telah membandingkan penggunaan SVM dengan algoritma yang lain
dalam Machine Learning. Beberapa keuntungan penggunaan SVM adalah:
1. Akurasi.
2. Bekerja dengan baik untuk data yang terbatas.
3. Kernel SVM memuat transformasi fungsi tak linear yang mengonversikan pemisah data
tak linear yang kompleks menjadi pemisah data yang linear.

4.3.2. Kerugian Algoritma SVM

Akan tetapi, ternyata SVM juga masih memuat hal-hal yang tidak baik, yaitu:
1. Tidak bekerja dengan baik untuk data yang lebih besar.
2. Kadang-kadang, waktu untuk data latih cukup lama.
Masalah optimasi pada SVM kemudian secara praktis dijelaskan berikut ini.
 Pengantar Support Vector Machine (SVM) 239

4.4. Apa yang Dilakukan Jika Pengali Lagrange Sudah Ada?

4.4.1. Hitung w
n
Hitung w sederhana saja karena w = w   y
i 1
i i xi dari persamaan (4.13). Setelah w diperoleh,

kita dapat menggunakan salah satu kendala dalam masalah primal untuk menghitung b:
yi (w.xi + b) -1≥ 1, i=1,...,n
Titik-titik terdekat pada hyperplane akan mempunyai fungsi margin 1 (di mana 1 dipilih ketika
kita putuskan bagaimana menskala w) sehingga:
yi (w.xi + b) =1.
Untuk mendapatkan b, kita kalikan kedua ruas dengan yi dan karena yi =1 maka diperoleh
w.xi + b = yi
b= yi - w.xi.
Dari teori machine learning yang lain, pemilihan vektor xi tidak dilakukan random, tetapi dengan
mencari rata-ratanya, yaitu
S
1
b
S   yi  w.xi 
i 1

Di mana S adalah banyaknya vektor support. Kemudian berkembang pula formula lain dalam
penyusunan b yang tidak dibahas dalam tulisan ini.

4.4.2. SVM dengan Solver QP

Bentuk paket dalam Python menyusun masalah kuadratik dalam bentuk
min 1
xT Px  qT x
x 2
dengan kendala
Gα h
Aα=b

Simbol  menyatakan pertidaksamaan per komponen vektor. Hal ini berarti setiap baris dari
matriks G λ menyatakan bahwa pertidaksamaan dipenuhi.
240 Machine Learning dengan Python

Pada kasus optimasi dual Wolfe, yang ingin diminimalkan adalah α. Untuk itu, kita perlu
mengubah masalah dual Wolfe (P.2.a)-(P.2.b) dengan mentransformasi menjadi masalah
pemaksimum, yaitu:
n n n
maksimumkan 1
 
i 1
i 
2  
i 1 j 1
i j y i y j xi . x j

dengan kendala
n
αi ≥ 0 , i =1,...,n dan  y
j 1
i i 0.

Kita perkenalkan notasi vektor α=[ α1 ,..., αn ]T dan y = [y1,...,yn]T dan matriks Gram K untuk
semua perkalian dot yang mungkin untuk vektor xi :

 x1 . x1 x1 . x2  x1 . xn 
 
x2 . x1 x2 . x2  x2 . xn 
K(x1, ..., xn) = 
     
 
 xn . x1 xn . x2  xn . xn 

Selanjutnya, kita dapat menyelesaikan masalah optimasi SVM dengan solver QP (Quadratic
Programming) dalam paket program Python CVXOPT.
Notasi di atas kemudian dapat digunakan untuk menuliskan masalah dual Wolfe, di mana yyT
yang menyatakan perkalian outer y b, yaitu:

minimalkan 1
 2

 T yyT K    
dengan kendala
  0
y.  0

Ringkasan:
Peminimalan norm w adalah masalah optimasi konveks yang dapat diselesaikan dengan
metode pengali Lagrange. Dengan menggunakan teori dualitas, kita dapat mentransformasi
masalah Lagrange menjadi masalah dual Wolfe. Kemudian disusun paket dalam Python yang
menggunakan masalah pemrograman kuadratik.
 Pengantar Support Vector Machine (SVM) 241

4.4.3. Masalah dengan Data Mempunyai Derau

Data yang mempunyai derau (noise) di mana justru sering terjadi. Demikian pula, misalkan
data mempunyai outlier (data pencilan) sebagaimana pada Gambar 4.26.

Gambar 4.26 Ilustrasi data memuat outlier pada posisi (7,8)

Untuk itu, SVM yang semula di atas perlu dimodifikasi dengan cara menambahkan variabel
slack  (sebut zeta). Jadi kendala yang semula

yi (w.xi + b) -1≥ 1,
menjadi

yi (w.xi + b) -1≥ 1-  i

Jadi, dapat terjadi kendala semula tidak terpenuhi, tetapi kita dapat menggunakan kendala
kedua. Ada banyak nilai  i sehingga persamaan nfungsi tujuan perlu diubah dan melakukan
metode regularisasi dengan menambahkan total 
 i sehingga fungsi tujuan, yaitu
i 1

n
minimalkan 1

2
w + i
w, b, 2 i 1
242 Machine Learning dengan Python

dengan kendala

yi (w.xi + b) -1≥ 1-  i , i=1,...,n

Akan tetapi, dapat terpikir bahwa meminimalkan dapat dikerjakan dengan menggunakan nilai
negatif  i . Untuk itu, perlu ditambahkan kendala  i ≥ 0 untuk mengatasi hal ini. Akan tetapi,
terkadang kita membutuhkan SVM yang mula-mula sehingga perlu ditambahkan parameter C
yang akan menentukan seberapa penting parameter  (lebih besar atau lebih kecil).
Sehingga kita dapat menyusun formulas soft margin
n
minimalkan 1

2
w +C i
w, b, 2 i 1

dengan kendala

yi (w.xi + b) -1 ≥ 1-  i , i=1,...,n
 i ≥ 0, i=1,...,n

Dengan menggunakan metode yang sudah dijelaskan di atas maka kita perlu memaksimalkan
masalah dual Wolfe yang sama di mana dengan sedikit kendala yang berbeda, yaitu:

n n n
maksimumkan 1
 i 1
i 
2  
i 1 j 1
i j y i y j xi . x j

dengan kendala
n
0  αi  C, i =1,...,n dan  y
j 1
i i 0.

 y
i 1
i i 0

Jadi kendala semula αi ≥ 0 berubah menjadi 0  αi  C yang disebut kendala kotak (box
constraint).
 Pengantar Support Vector Machine (SVM) 243

4.4.4. Bagaimana Perilaku C?

Perhatikan bahwa jika C menuju tak hingga maka masalah di atas adalah SVM klasik (hard
margin). Jika kita memilih C nilai kecil maka hyperplane akan dekat pada beberapa titik. Jika C
dipilih sangat dekat ke nol maka seolah tidak ada kendala maka kita mendapatkan hyperplane
tanpa klasifikasi. Apakah pemilihan C besar merupakan pilihan terbaik?
Untuk data yang memuat outlier dengan C = 1 maka diperoleh hyperplane yang akan
dekat dengan hard margin (SVM mula-mula) tanpa outlier. Untuk C = 0.01 maka dapat terjadi
melanggar kendala. Pada kasus di mana outlier tidak terpisah, kita tidak dapat menggunakan
C= - tak hingga karena tidak ada solusi yang memenuhi semua kendala pada hard margin atau
SVM mula-mula. Sebagai penggantinya maka C perlu dites untuk beberapa nilai.
Jadi aturan pemilihan C sebagai berikut:
1. C yang kecil akan membuat margin yang lebar, tetapi dapat memberikan misklasifikasi.
2. Nilai C yang besar akan memberikan hard margin (SVM mula-mula) dan menoleransi
kendala 0 dilanggar.
Untuk itu, pemilihan C dibuat sedemikian hingga derau data tidak terlalu memengaruhi
penyelesaian. Tidak ada cara tepat yang akan bekerja untuk semua masalah. Pendekatan
yang direkomendasikan adalah menggunakan pencarian grid dengan validasi silang. Hal
penting yang harus dipahami adalah bahwa nilainya sangat khusus untuk data yang Anda
gunakan, jadi jika suatu hari Anda menemukan bahwa C=0,001 tidak berfungsi untuk salah
satu masalah, Anda harus tetap mencoba nilai C ini dengan masalah lain karena tidak akan
ada efek yang sama. Selanjutnya, yang perlu kita lakukan adalah mengganti berbagai nilai
C karena untuk tiap kasus dapat berbeda-beda. Pada Gambar 4.27 ditunjukkan pengaruh
berturut-turut untuk nilai C tak hingga C=1, C=0.01 dengan klasifikasi linear.

Gambar 4.27 Ilustrasi data terklasifikasi linear

244 Machine Learning dengan Python

4.4.5. Perumusan Lain Soft Margin

Karena skala C dipengaruhi oleh ruang fitur (variabel independen) maka diusulkan formula lain,
yaitu nuSVM di mana ide dasarnya adalah menambahkan variabel υ yang nilainya bervariasi
antara 0 dan 1 sebagai pengganti C. Selain itu, parameter υ hanya bergantung pada tingkat
derau pada data. Masalah optimasi yang diselesaikan, yaitu:
n n
maksimumkan 1


2  
i 1 j 1
i j y i y j xi . x j

dengan kendala
1
0 i 
n
n

 y
j 1
i i 0.


j 1
i   untuk i=1,...,n.

4.5. Bagaimana Mengklasifikasi Data yang Terpisah tidak Linear?

Sebagaimana ditunjukkan pada gambar berikut dapat terlihat bahwa dua kelas data tidak
terpisah secara linear.

Gambar 4.28 Ilustrasi data terklasifikasi tidak linear

 Pengantar Support Vector Machine (SVM) 245

Cara yang mungkin dilakukan adalah mentransformasi data vektor 2 dimensi menjadi vektor
3 dimensi.

Contoh 4.3
Misalkan dilakukan pemetaan polinomial  :  2  3 yang didefinisikan oleh


  x1, x2   x12 ,  2 x1 x2 , x22 
Diperoleh bahwa data semula pada bidang menjadi ruang 3 dimensi.

Gambar 4.29 Data masih tidak terpisah secara linear pada ruang 3 dimensi

Untuk itu, perlu diketahui transformasi apa yang dapat digunakan. Beberapa petunjuk sebagai
berikut:
1. Transformasikan setiap vektor 2 dimensi dalam suatu vektor 3 dimensi menggunakan
metode transformasi (pada Code sudah ada).
2. Lakukan uji SVM pada data 3 dimensi.
3. Untuk setiap contoh baru yang akan diduga, transformasikan dengan menggunakan
metode transformasi sebelum melakukan pendugaan.
246 Machine Learning dengan Python

4.5.1. Bagaimana Kita Tahu Transformasi apa yang Bisa Digunakan?

Memilih transformasi mana yang akan diterapkan sangat bergantung pada kumpulan data
Anda. Data mampu bertransformasi sehingga algoritma pembelajaran mesin yang ingin Anda
gunakan bekerja sebaik mungkin yang merupakan salah satu faktor kunci kesuksesan di
dunia Machine Learning. Sayangnya, tidak ada resep yang sempurna dan itu akan datang
dengan pengalaman melalui coba-coba. Sebelum menggunakan algoritma apa pun, pastikan
untuk memeriksa apakah ada beberapa aturan umum untuk mengubah detail data dalam
dokumentasi. Untuk informasi selengkapnya tentang cara menyiapkan data, Anda dapat
membaca transformasi dataset di situs web scikit-learn (Varoquaux et al., 2015).
Formulasi soft-margin SVM merupakan peningkatan yang bagus dibandingkan hard-
margin classifier. Formulasi soft-margin SVM memungkinkan kita untuk mengklasifikasikan data
dengan benar bahkan ketika ada data memuat noise yang merusak klasifikasi linier. Namun,
biaya dari fleksibilitas tambahan ini adalah bahwa kita sekarang memiliki hyperparameter,
untuk itu kita perlu menemukan nilai. Kita melihat bagaimana mengubah nilai berdampak
pada margin dan memungkinkan pengklasifikasi untuk membuat beberapa kesalahan agar
memiliki margin yang lebih besar. Ini sekali lagi mengingatkan kita, bahwa tujuan kita adalah
menemukan hipotesis yang akan bekerja dengan baik pada data yang tidak terlihat. Beberapa
kesalahan pada data pelatihan bukanlah hal yang buruk jika model menggeneralisasi dengan
baik pada akhirnya.
Pada scikit learn, nuSVM dinyatakan dalam NuSVC adalah klasifikasi vektor dukungan
Nu. Ini adalah kelas lain yang disediakan oleh scikit learn yang dapat melakukan klasifikasi
multikelas. Ini seperti SVC, tetapi NuSVC menerima sedikit set parameter yang berbeda.
Parameter yang berbeda dari SVC adalah:

nu: float, opsional, default = 0,5

Ini mewakili batas atas pada fraksi kesalahan pelatihan dan batas bawah dari sebagian
kecil dari vektor dukungan. Nilainya harus dalam interval (0,1). Parameter dan atribut lainnya
sama dengan SVC.
 Pengantar Support Vector Machine (SVM) 247

4.6. Kernel
Kita perlu resep cepat untuk digunakan pada kumpulan data yang tidak dapat dipisahkan. Salah
satu kekurangannya adalah kita harus mengubah setiap contoh. Jika kita memiliki jutaan atau
miliaran contoh dan metode transformasi, itu merupakan hal rumit yang bisa menghabiskan
banyak waktu. Ini saatnya kernel datang untuk menyelamatkan. Kita ingat pengali Laggrange
KKT dalam fungsi Wolfe Dual Lagrangian, kita tidak perlu nilai dari data training x; yang kita
perlukan adalah perkalian dot product
n n n
1
W   
i 1
i 
2  
i 1 j 1
i j y i y j xi . x j .

Perhatikan contoh berikut, di mana kita hanya memperhatikan dot product.

Contoh 4.4
Kita akan menggunakan pemetaan polinomial  :  2  3 yang didefinisikan oleh:


  x1, x2   x12 ,  2 x1 x2 , x22 
Kita tahu bahwa data semula pada bidang menjadi ruang 3 dimensi.
Berikut kode yang terbalik.
import numpy as np
def transform(x):
return [x[0]**2, np.sqrt(2)*x[0]*x[1], x[1]**2]
x1 = [3,6]
x2 = [10,10]
x1_3d = transform(x1)
x2_3d = transform(x2)
print(np.dot(x1_3d,x2_3d))
“””Apakah ada cara tanpa menghitung hal ini, itulah
kernel dibuat
“””
def polynomial_kernel(a, b):
248 Machine Learning dengan Python

return a[0]**2 * b[0]**2 + 2*a[0]*b[0]*a[1]*b[1] +

a[1]**2 * b[1]**2

x1 = [3,6]
x2 = [10,10] # disini tanpa transport data
print(polynomial_kernel(x1, x2)) # 8100

Fungsi kernel menghitung dot product mereka seolah-olah mereka telah diubah menjadi
vektor pada ruang lain, itu dilakukan tanpa melakukan transformasi, dan tanpa menghitung
dot product. Singkatnya kernel adalah fungsi yang mengembalikan hasil dot product yang
dilakukan di ruang lain. Lebih formal, kita dapat menulis:

Definisi:
Diberikan suatu fungsi pemetaan, yaitu:  : X  V , kita panggil fungsi K : X  V yang
didefinisikan dengan K(x,y) =   x  ,  y V .
Nah, dari sini kita akan mendapatkan ide trik Kernel, misalkan Kernel yang kita gunakan adalah
dot product maka kita dapat menulis soft-margin dual problem sebagai:
n n n
maksimumkan 1
 i 1
i 
2  
i 1 j 1
i j y i y j K xi . x j

dengan kendala

0 i  C untuk sebarang i=1,2,…,n

n

 y
i 1
i i 0.

Perubahan ini terlihat sangat sederhana, tetapi perlu diingat bahwa dibutuhkan kerja keras
untuk menurunkan formulasi ganda Wolf dari masalah pengoptimalan awal. Kita sekarang
memiliki kekuatan mengubah fungsi kernel untuk mengklasifikasikan data yang tidak dapat
dipisahkan. Tentu saja, kita juga perlu mengubah fungsi hipotesis untuk menggunakan fungsi
kernel:
 Pengantar Support Vector Machine (SVM) 249

Ingatlah bahwa dalam rumus ini adalah himpunan vektor pendukung (support vector).
Melihat rumus ini, kita lebih memahami mengapa SVM juga disebut sparse kernel machine. Itu
karena mereka hanya perlu menghitung fungsi kernel pada vektor pendukung dan tidak pada
semua vektor, seperti metode kernel lainnya.

4.6.1. Tipe Kernel

Terdapat beberapa kernel yang sebenarnya sudah kita kenal.
1. Kernel Linear, yaitu K(x,y) = x.y.
2. Kernel Polinomial. Kita menuliskan dalam bentuk yang lebih umum, yaitu: K(x,y) = (x.y +
c)d.
Ini memiliki dua parameter: c yang mewakili suku konstanta dan d yang mewakili derajat kernel.
Kernel ini dapat diimplementasikan dengan mudah di Python.

def kernelpolinomial(a, b, derajat, konstan=0):

hasil = sum([a[i] * b[i]
for i in range(len(a))]) + konstan
return pow(hasil, derajat)

Kemudian kernel tersebut dicoba digunakan:

x1 = [3,6]
x2 = [10,10] # kita tidak transform data.
print(kernelpolinomial(x1, x2, derajat=2)) #
250 Machine Learning dengan Python

Gambar 4.30 Ilustrasi SVM dengan pemisahan data tak linear

Kernel polinomial dengan derajat 1 dan tanpa konstanta hanyalah kernel linier. Saat Anda
meningkatkan derajat kernel polinomial, batas keputusan akan menjadi lebih kompleks dan
cenderung dipengaruhi oleh contoh data individual. Menggunakan polinomial derajat tinggi
berbahaya karena Anda seringkali dapat mencapai hasil kinerja yang lebih baik pada set
pengujian anda, tetapi mengarah ke apa yang disebut overfitting: model terlalu dekat dengan
data dan tidak menggeneralisasi dengan baik.
 Pengantar Support Vector Machine (SVM) 251

DAFTAR PUSTAKA
Kowalczyk, A. 2017. Support Vector Machines Succintctly. www.syncfusion.com.
Varoquaux, G., Buitinck, L., Louppe, G., Grisel, O., Pedregosa, F., & Mueller, A. 2015. Scikit-
learn. GetMobile: Mobile Computing and Communications, 19 (1), 29–33. https://doi.
org/10.1145/2786984.2786995.
BAB 5
POHON KEPUTUSAN
(DECISION TREE/DT)

Pada bagian ini, akan dibahas tentang pohon keputusan yang berguna untuk klasifikasi, tetapi
juga regresi. Untuk menyimpulkan hasil klasifikasi digunakan CM (Confusion Matrix). Untuk itu,
perlu dipahami terlebih dahulu CM.

5.1. Sejarah dan Pengertian Umum Confusion Matrix

Confusion matrix pertama kali diperkenalkan oleh ilmuwan statistik Harold Hotelling pada tahun
1947. Hotelling mengembangkan konsep matriks kebingungan (Confusion Matrix) sebagai
alat untuk mengevaluasi kinerja model klasifikasi dalam konteks analisis statistik. Namun,
pada saat itu, konsep ini lebih banyak digunakan dalam konteks uji hipotesis dan pengujian
signifikansi daripada dalam pemodelan prediktif.
Seiring dengan berkembangnya teknologi komputer dan kebutuhan untuk memodelkan
dan memprediksi data dalam skala yang lebih besar, confusion matrix mulai digunakan secara
lebih luas dalam dunia machine learning dan data science pada tahun 1980-an dan 1990-an.
Dalam konteks klasifikasi, confusion matrix menjadi alat penting untuk mengukur performa
model dalam memprediksi kelas target dan membantu pengambilan keputusan yang lebih
baik.
Hingga saat ini, confusion matrix tetap menjadi alat yang sangat penting dalam evaluasi
model machine learning, dan telah digunakan dalam berbagai jenis masalah prediksi, termasuk
dalam bidang kesehatan, bisnis, keuangan, dan lain-lain. Berikut adalah beberapa literatur
yang dapat digunakan sebagai referensi untuk mempelajari lebih lanjut tentang confusion
matrix:
254 Machine Learning dengan Python

1. Buku tentang pengantar yang komprehensif tentang data science, termasuk penggunaan
confusion matrix dalam evaluasi performa model (Kelleher & Brendan, 2018).
2. Data Science for Business: What You Need to know about Data Mining and Data-Analytic
Thinking. Buku ini memberikan gambaran yang lengkap tentang data science dari
perspektif bisnis dan menjelaskan bagaimana confusion matrix dapat digunakan dalam
evaluasi model (Provost & Fawcett, 2013).
3. Evaluation: From Precision, Recall and F-measure to ROC, Informedness, Markedness
and Correlation merupakan judul artikel tentang berbagai metrik evaluasi model, termasuk
akurasi, presisi, recall, F1-score, dan area under the ROC curve yang dapat dihitung
menggunakan confusion matrix (Beschi Raja et al., 2019).
4. Artikel yang berjudul A Review on Ensembles for the Class Imbalance Problem: Bagging,
boosting, and Hybrid-Based Approaches membahas tentang bagaimana confusion matrix
dapat digunakan dalam penanganan masalah ketidakseimbangan kelas dalam masalah
klasifikasi (Zhang et al., 2021).
5. Precision and Recall. In Encyclopaedia of Machine Learning sebagai bagian dari
ensiklopedia menjelaskan konsep precision dan recall dalam konteks evaluasi model
menggunakan confusion matrix (Carterette, 2011).
Confusion matrix pada pohon keputusan adalah tabel yang digunakan untuk mengevaluasi
performa model pohon keputusan. Confusion matrix terdiri dari empat sel yang mewakili empat
kemungkinan hasil klasifikasi yang mungkin terjadi, yaitu True Positive (TP), False Positive
(FP), True Negative (TN), dan False Negative (FN). True Positive (TP) adalah ketika model
memprediksi suatu kasus sebagai positif dan kasus tersebut memang benar-benar positif.
False Positive (FP) adalah ketika model memprediksi suatu kasus sebagai positif, tetapi kasus
tersebut sebenarnya negatif. True Negative (TN) adalah ketika model memprediksi suatu kasus
sebagai negatif dan kasus tersebut memang benar-benar negatif. False Negative (FN) adalah
ketika model memprediksi suatu kasus sebagai negatif, tetapi kasus tersebut sebenarnya
positif. Dalam pohon keputusan, CM digunakan untuk mengukur performa model dalam
memprediksi kelas target. Misalnya, dalam masalah klasifikasi biner, kita dapat menggunakan
CM untuk menghitung akurasi, presisi, recall, F1-score, dan lain sebagainya. Confusion matrix
juga dapat digunakan untuk memvisualisasikan performa model dalam bentuk heatmap, yang
memudahkan pemahaman dan interpretasi hasil evaluasi model.
 Pohon Keputusan (Decision Tree/DT) 255

5.2. Confusion Matrix (CM)

CM adalah teknik menyimpulkan algoritma klasifikasi di mana akurasi klasifikasi sering kali
membawa pada pesan yang salah di mana terkait dengan banyaknya observasi pada tiap
kelas yang berbeda dan lebih dari 1 kelas. Perhitungan CM dapat memberikan ide klasifikasi
model lebih baik dan tipe error mana yang dibuat. Hal yang dapat dipelajari pada CM:
Ada 2 kemungkinan kelas dugaan: YA dan TIDAK, jika kita sedang menduga ada tidaknya
virus maka jawaban YA menunjukkan bahwa mereka punya virus dan TIDAK berarti tidak
bervirus. Dari 165 kasus, kelompok yang diduga YA terdapat 110 (kolom ke-2) dan yang
TIDAK ada 55 (kolom ke-1). Secara realitas, 105 pasien pada sampel mempunyai virus (YA),
sedangkan 60 orang pasien dan yang tidak bervirus adalah 60. Sekarang kita akan melakukan
definisi dasar:
Kebenaran positif (BP): ada kasus-kasus yang kita duga YA (bervirus) dan yang TIDAK (tidak
bervirus).
Kebenaran negatif (BN): kita menduga TIDAK dan mereka TIDAK bervirus.
Kesalahan positif (SP): kita menduga YA, tetapi pada kenyataannya mereka TIDAK bervirus
(Error tipe 1).
Kesalahan negatif (SN): kita menduga TIDAK, tetapi mereka sebenarnya bervirus (YA) (Error
tipe II).
Kita menambahkan informasi ini pada CM pada baris dan kolom sebagai berikut.
Akurasi didefinisikan menjadi: (BN+BP)/165=(100+50)/165=0.91
Laju misklasifikasi (1-Akurasi) =
(SP+SN)/total = (10+5)/165=0.09
Yang disebut juga laju error.
Akurasi didefinisikan menjadi: (BN+BP)/10=(4+3)/10=0.7.
Laju misklasifikasi (1-Akurasi) = 0.3 yang disebut juga laju error.
Sedangkan laju benar positif:
BP/nilai aktual YA =3/7
256 Machine Learning dengan Python

Laju salah positif: jika aktual TIDAK, seberapa sering diduga YA:
BN/aktual TIDAK=
Sama dengan 1-SLaju salah positif atau spesifisitas.
Presisi: jika diduga YA, seberapa sering dijawab benar:
BP/dugaan YA = …
Prevalensi: seberapa sering kondisi YA secara aktual terjadi pada sampel:
Aktual YA/total = …
Laju nol error: seberapa sering kita salah jika selalu menduga kelas yang besar:
Akan tetapi dalam aplikasi, sering dijumpai data dengan variabel banyak sehingga CM tidak
mungkin hanya 2 x 2. Penjelasan perlu lebih detail dan belum dijelaskan di sini. Secara grafis,
terdapat pula cara mengukur baiknya klasifikasi dengan kurva yang disebut kurva ROC. Kurva
ROC adalah grafik yang biasa digunakan untuk meringkas penampilan suatu klasifikasi pada
semua percabangan yang dibentuk dengan menggambar laju kebenaran positif pada sumbu
y, dan laju kesalahan positif pada sumbu x. Pada model aplikasi dugaan dengan statistika
Bayesian, sensitivitas dan spesifikasi adalah probabilitas bersyarat, prevalensi (fakta-
fakta yang sering terjadi sebelumnya 0), dan nilai-nilai dugaan positif atau negatif sebagai
probabilitas posterior.
Akurasi klasifikasi adalah rasio antara dugaan benar terhadap total dugaan yang dibuat, yaitu
akurasi klasifikasi = dugaan benar/total dugaan, sedangkan persentasenya berarti mengalikan
besar rasio tersebut dengan 100 agar 100 persen. Ada pula yang membahas akurasi dengan
laju ketidaktepatan klasifikasi (misclassification) atau laju error, yaitu laju error = (1-dugaan
benar/total dugaan))x 100.

Contoh 5.1a
Misalkan CM berikut ini.
Dugaan Dugaan
N=165
TIDAK YA
Aktual
50 10
TIDAK
Aktual
5 100
YA
 Pohon Keputusan (Decision Tree/DT) 257

Yang dapat dipelajari pada CM ini:

Ada 2 kemungkinan kelas dugaan: YA dan TIDAK jika kita sedang menduga ada tidaknya virus
maka jawaban YA menunjukkan bahwa mereka punya virus dan TIDAK berarti tidak bervirus.
Dari 165 kasus, kelompok yang diduga YA terdapat 110 (kolom ke-2) dan yang TIDAK ada 55
(kolom ke-1). Secara realitas, 105 pasien pada sampel mempunyai virus (YA), sedangkan 60
orang pasien dan yang tidak bervirus adalah 60. Sekarang kita akan melakukan definisi dasar:
Kebenaran positif (BP): ada kasus-kasus yang kita duga YA (bervirus) dan yang TIDAK (tidak
bervirus).
Kebenaran negatif (BN): kita menduga TIDAK dan mereka TIDAK bervirus.
Kesalahan positif (SP): kita menduga YA, tetapi pada kenyataannya mereka TIDAK bervirus
(Error tipe 1).
Kesalahan negatif (SN): kita menduga TIDAK, tetapi mereka sebenarnya bervirus (YA) (Error
tipe II).
Kita menambahkan informasi ini pada CM pada baris dan kolom sebagai berikut.

Contoh 5.1b
Misalkan CM berikut ini.
N=165 Dugaan TIDAK Dugaan YA
Aktual TIDAK BN = 50 SP=10 60
Aktual YA SN =5 BP=100 105
55 110

Akurasi didefinisikan menjadi: (BN+BP)/165=(100+50)/165=0.91

Laju misklasifikasi (1-Akurasi) =
(SP+SN)/total = (10+5)/165=0.09
Yang disebut juga laju error.
Sedangkan laju benar positif:
BP/nilai aktual YA =100/105=0.95
Laju salah positif: jika aktual TIDAK, seberapa sering diduga YA:
BN/aktual TIDAK= 50/60=0.83
Sama dengan 1-SLaju salah positif atau spesifisitas.
Presisi: jika diduga YA, seberapa sering dijawab benar:
258 Machine Learning dengan Python

BP/dugaan YA = 100/110=0.91
Prevalensi: seberapa sering kondisi YA secara aktual terjadi pada sampel:
Aktual YA/total =105/165
Laju nol error: seberapa sering kita salah jika selalu menduga kelas yang besar: 60/165.

5.3. Pendahuluan Pohon Keputusan

Decision Tree (DT) adalah salah satu SML (Supervised Machine Learning) algoritma yang
dapat digunakan untuk regresi sekaligus klasifikasi. Untuk setiap atribut/fitur dalam data maka
dalam algoritma pohon keputusan dibentuk sebagai node di mana atribut yang terpenting
dianggap pada akar pohon. Untuk evaluasi, kita mulai dari node akar dan menurun dengan
mengikuti keputusan yang dibuat hingga pada node yang terakhir yang menghasilkan prediksi
dari pohon keputusan. Secara umum, kita dapat menggambarkan DT dalam bentuk Gambar
5.1.

Gambar 5.1 Contoh struktur pohon keputusan (decision tree)

Waktu pelatihannya lebih cepat dibandingkan dengan algoritma jaringan saraf.

Kompleksitas waktu pohon keputusan adalah fungsi dari jumlah catatan dan atribut dalam data
yang diberikan. Pohon keputusan adalah metode bebas distribusi atau non-parametrik yang
tidak bergantung pada asumsi distribusi probabilitas. Pohon keputusan dapat menangani data
berdimensi tinggi dengan akurasi yang baik.
 Pohon Keputusan (Decision Tree/DT) 259

Dalam membangun algoritma pohon keputusan maka diperlukan penetapan maksimum

kedalaman pohon keputusan, misalkan digunakan satu parameter max_depth yang digunakan
untuk menentukan kedalaman maksimum dari pohon keputusan yang akan dibangun. Pertama-
tama, konstruktor menginisialisasi variabel self.max_depth dengan nilai yang diberikan pada
saat objek dibuat. Variabel ini akan digunakan pada saat membangun pohon keputusan untuk
membatasi kedalaman maksimum pohon. Jika parameter max_depth tidak diberikan (atau
diberikan nilai None) maka pohon keputusan tidak akan dibatasi oleh kedalaman maksimum.
Jika parameter max_depth diberikan dengan nilai tertentu maka pohon keputusan akan
dibangun dengan kedalaman maksimum sesuai nilai tersebut. Dalam konteks machine learning,
pembatasan kedalaman maksimum pohon keputusan dapat membantu mencegah overfitting
(memperbaiki kinerja model pada data pelatihan dengan mengorbankan kinerja model pada
data uji atau data yang tidak terlihat sebelumnya). Sebaliknya, jika pohon keputusan tidak
dibatasi oleh kedalaman maksimum, model mungkin akan terlalu kompleks dan menyesuaikan
diri terlalu baik dengan data pelatihan sehingga kinerjanya pada data uji menjadi buruk.

5.3.1. Cara Kerja Decision Tree

1. Bagaimana pemilihan atribut pada Decision Tree?
Ukuran pemilihan atribut adalah heuristik untuk memilih kriteria pemisahan yang mempartisi
data dengan cara terbaik. Ini juga dikenal sebagai aturan pemisahan karena membantu
kita menentukan breakpoint untuk tupel pada node tertentu. Attribute Selection Method
(ASM) memberikan peringkat untuk setiap fitur (atau atribut) dengan menjelaskan dataset
yang diberikan. Atribut skor terbaik akan dipilih sebagai atribut pemisahan (sumber).
Dalam kasus atribut bernilai kontinu, titik pisah untuk cabang juga perlu ditentukan.
Ukuran seleksi yang paling populer digunakan adalah impurity (ketidakmurnian). Untuk
memahami hal ini, mari kita cermati contoh berikut.

Gambar 5.2 Bola dengan warna sama dan berbeda

260 Machine Learning dengan Python

Dari Gambar 5.2, sebuah bola diambil secara acak dari setiap mangkuk. Jadi berapa
banyak informasi yang Anda butuhkan untuk mengetahui warna bola secara akurat?
Mangkuk kiri membutuhkan lebih sedikit informasi karena semua bola berwarna cokelat,
mangkuk tengah membutuhkan lebih banyak informasi daripada mangkuk kiri untuk
mengatakannya secara akurat, dan mangkuk kanan membutuhkan informasi maksimal
karena kedua jumlah bola berwarna sama. Ada beberapa ukuran impurity yang ada, tetapi
dalam cerita ini kita hanya akan berbicara tentang dua ukuran tersebut, yaitu Entropi dan
Indeks Gini/Impurity Gini.
a. Entropi
Entropi adalah jumlah informasi yang diperlukan untuk menggambarkan secara
akurat beberapa sampel. Jadi jika sampelnya homogen, berarti semua elemennya
mirip maka entropinya adalah 0, sebaliknya jika sampelnya terbagi rata maka
entropinya maksimal 1.
n
Entropi  D    p * log  p 
i 1
i i

Di mana pi adalah probabilitas bahwa elemen D dalam kelas Ci.

b. Indeks Gini/Impurity Gini
Indeks gini adalah ukuran ketimpangan dalam sampel yang memiliki nilai antara
0 dan 1. Indeks gini nilai 0 berarti sampel homogen sempurna dan semua elemen
serupa, sedangkan indeks gini nilai 1 berarti ketidaksetaraan maksimal antarelemen.
Ini adalah jumlah kuadrat dari probabilitas masing-masing kelas. Diilustrasikan
sebagai,
n
IndeksGini  1  p
i 1
2
i

Algoritma pohon keputusan adalah pohon di mana simpul mewakili fitur (atribut), cabang
mewakili keputusan (aturan), dan simpul daun mewakili hasil (diskrit dan kontinu). Jadi
sebenarnya bagaimana algoritma pohon keputusan dibangun? Ada berbagai macam
algoritma yang digunakan untuk membangkitkan pohon keputusan dari data, di antaranya
adalah klasifikasi dan pohon regresi, CART, ID 3, CHAID (Chi-squared Automatic
Interaction Detector), dan ID 4.5. Meskipun metodenya berbeda untuk setiap algoritma
pembangunan pohon keputusan yang berbeda, tetapi semuanya bekerja berdasarkan
 Pohon Keputusan (Decision Tree/DT) 261

prinsip pemaksimuman informasi. Algoritma mencoba mencari variabel yang memberikan

perolehan informasi maksimum atau membagi data dengan cara yang paling homogen.
Tetapi yang akan kita bahas hanya CART. Jadi, mari kita mulai dengan membuat pohon
klasifikasi dengan bantuan algoritma CART. CART digunakan untuk menghasilkan pohon
klasifikasi dan pohon regresi. Ini menggunakan Indeks Gini sebagai fungsi metrik/biaya
untuk mengevaluasi pemisahan dalam pemilihan fitur dalam kasus pohon klasifikasi.
CART digunakan untuk klasifikasi biner. CART menggunakan kuadrat terkecil sebagai
metrik untuk memilih fitur dalam kasus pohon regresi. Mari kita mulai dengan kumpulan
data cuaca yang cukup terkenal dalam menjelaskan algoritma pohon keputusan, di mana
targetnya adalah untuk memprediksi permainan atau tidak (Ya atau Tidak) berdasarkan
kondisi cuaca.
Contoh 5.2
Katakanlah Anda ingin mengidentifikasi kesuksesan film, tetapi Anda hanya dapat menggunakan
satu variabel. Ada dua cara untuk melakukannya:
Anda dapat dengan jelas mengamati bahwa metode pertama (berdasarkan aktor
utama) membagi data dengan sangat baik, sementara metode kedua (berdasarkan Genre)
menghasilkan hasil yang beragam. Algoritma pohon keputusan melakukan hal yang sama
ketika harus memilih variabel. Ada berbagai metrik yang digunakan pohon keputusan untuk
mengetahui variabel pemisah terbaik. Kita akan membahasnya satu per satu dan mencoba
memahami dengan entropi.

Aktor Utama Genre Dipilih (Ya/Tidak)

Amitabh Bachchan Aksi Ya
Amitabh Bachchan Fiksi Ya
Amitabh Bachchan Roman Tidak
Amitabh Bachchan Aksi Ya
Abhishek Bachchan Aksi Tidak
Abhishek Bachchan Fiksi Tidak
Abhishek Bachchan Roman Ya

Kata Entropi dipinjam dari termodinamika yang merupakan ukuran variabilitas atau
kekacauan atau keacakan. Shannon memperluas konsep entropi termodinamika pada tahun
1948. Dengan asumsi Anda memutar koin yang adil dan ingin mengetahui sistem entropi.
Sesuai rumus yang diberikan oleh Shann, entropi akan sama dengan -[0,5 ln(0,5) + 0,5 ln(0,5)]
262 Machine Learning dengan Python

= -0.69 yang merupakan entropi maksimum yang dapat terjadi dalam sistem. Dengan kata
lain, akan ada keacakan maksimum dalam kumpulan data kita, jika hasil yang mungkin memiliki
probabilitas kejadian yang sama. Kita dapat dengan jelas melihat bahwa entropi maksimum
ketika probabilitas salah satu kelas sama. Sekarang, kita dapat memahami bahwa ketika
algoritma keputusan mencoba membagi data, ia memilih variabel yang akan memberi kita
pengurangan maksimum dalam sistem entropi.
Sebagai contoh tingkat keberhasilan film. Entropi awal disebut entropi induk dalam sistem
adalah:
Entropi Induk = -(0,57*ln(0,57) + 0,43*ln(0,43)) = 0.68 (entropi awal sering disebut entropy-
parent).

Entropi Setelah Pemisahan Metode 1

Entropi kiri = -(.75*ln(0.75) + 0.25*ln(0.25)) = 0.56
Entropi kanan = -(.33*ln(0.33) + 0.67*ln(0.67)) = 0.63
Entropi yang ditangkap setelah pemisahan data menggunakan metode 1 dapat dihitung
menggunakan rumus berikut: Entropi (Induk) - Rata-Rata berbobot Entropi Anak, yaitu:
0,68 – (4*0,56 + 3*0,63)/7 = 0,09. Angka 0,09 ini umumnya dikenal sebagai “Information Gain”.

Entropi Setelah Pemisahan Metode 2

Entropi kiri = -(.67*ln(0.67) + 0.33*ln(0.33)) = 0.63
Entropi tengah = -(.5*ln(0.5) + 0.5*ln(0.5)) = 0.69
Entropi kanan = -(.5*ln(0.5) + 0.5*ln(0.5)) = 0.69
Sekarang dengan menggunakan metode yang digunakan di atas, kita dapat menghitung
Penguatan Informasi (Gain Information) sebagai:
Perolehan Informasi = 0,68 – (3*0,63 + 2*0,69 + 2*0,69)/7 = 0,02
Oleh karena itu, kita dapat dengan jelas melihat bahwa Metode 1 memberi kita lebih dari 4 kali
perolehan informasi dibandingkan dengan Metode 2 dan karenanya Metode 1 adalah variabel
split terbaik.
 Pohon Keputusan (Decision Tree/DT) 263

Contoh 5.3
“””DecisionTree1.ipynb
Automatically generated by Colaboratory.
Original file is located at
https://colab.research.google.com/drive/1v-
2TINj345wUJ40r5arNg7G0CcCRy5PV
“””
import pandas as pd
import pydotplus #pip install pydotplus
from sklearn.tree import export_graphviz
from sklearn.tree import DecisionTreeClassifier
import numpy as np
data = pd.DataFrame({‘P_Film’: [17,64,18,20,38,49,55,2
5,29,31,33],
‘Gender’: [1,0,1,0,1,0,0,1,1,0,1]})
data =data.sort_values(‘P_Film’)
data
def tree_graph_to_png(tree, feature_names, png_file_to_
save):
tree_str = export_graphviz(tree, feature_
names=feature_names,
filled=True, out_
file=None)
graph = pydotplus.graph_from_dot_data(tree_str)
graph.write_png(png_file_to_save)

#Buat decision tree

dt = DecisionTreeClassifier(criterion = ‘entropy’)
#Define input vectors
#X : fitur dalam dataset
264 Machine Learning dengan Python

X = data[‘P_Film’].values.reshape(-1, 1)
#Y : vektor variabel target
Y = data[‘Gender’].values
#mulai fitting
dt.fit(X, Y)
tree_graph_to_png(dt, feature_names=[‘P_Film’],
png_file_to_save=’dt.png’)
d = np.array([7, 15, 43, 45])
d=d.reshape(-1, 1)
dt.predict(d)

5.3.2. Implementasi DT dengan Scikit Learn Python untuk Cek Keaslian Uang
Kertas
Pada bagian ini, akan ditunjukkan bagaimana menggunakan algoritma DT dengan library Scikit
Learn di mana kasus yang dipelajari diselesaikan dengan klasifikasi dan regresi.
Contoh 5.4 DT untuk Banknote (BN)
Dalam bahasa Indonesia, Banknote (BN) adalah uang kertas yang bernilai dengan satuan
tertentu. Masalah yang dicermati adalah bagaimana mengidentifikasi BN asli atau tidak.
Pada bagian ini, kita akan menduga apakah BN merupakan asli atau tidak asli dengan 4
atribut gambar yang berbeda pada BN tersebut. Atribut yang digunakan adalah variansi dari
transformasi wavelet pada gambar, kurtosis pada gambar, entropi, dan skewness dari gambar
(digunakan pada program dalam bahasa Inggris: Variance, Skewness, Curtosis, Entropy,
Class), sedangkan label adalah class bernilai 0 dan 1. Dari sumber tidak dijelaskan apakah
yang bertanda 0 untuk yang asli atau yang tidak asli.
1. Sumber Data
Pemilik data: Volker Lohweg (University of Applied Sciences, Ostwestfalen-Lippe, volker.
lohweg ‘@’ hs-owl.de).
Penyumbang data: Helene Dörksen (University of Applied Sciences, Ostwestfalen-
Lippe, helene.doerksen ‘@’ hs-owl.de).
Data diterima pada: August, 2012.
 Pohon Keputusan (Decision Tree/DT) 265

Data diambil dari: https://archive.ics.uci.edu/ml/datasets/banknote+authentication dengan

nama file bill_authentication.csv. Jika file dibuka akan berisi:
“Variance,Skewness,Curtosis,Entropy,Class”
“3.6216,8.6661,-2.8073,-0.44699,0”
“4.5459,8.1674,-2.4586,-1.4621,0”
“3.866,-2.6383,1.9242,0.10645,0”
“3.4566,9.5228,-4.0112,-3.5944,0”
“0.32924,-4.4552,4.5718,-0.9888,0”
“4.3684,9.6718,-3.9606,-3.1625,0”
“3.5912,3.0129,0.72888,0.56421,0”
“2.0922,-6.81,8.4636,-0.60216,0”
“3.2032,5.7588,-0.75345,-0.61251,0”
“1.5356,9.1772,-2.2718,-0.73535,0”
“1.2247,8.7779,-2.2135,-0.80647,0”
“3.9899,-2.7066,2.3946,0.86291,0”
.
.
.
“0.066129,2.4914,-2.9401,-0.62156,1”
“-0.24745,1.9368,-2.4697,-0.80518,1”
“-1.5732,1.0636,-0.71232,-0.8388,1”
“-2.1668,1.5933,0.045122,-1.678,1”
“-1.1667,-1.4237,2.9241,0.66119,1”
“-2.8391,-6.63,10.4849,-0.42113,1”
“-4.5046,-5.8126,10.8867,-0.52846,1”
“-2.41,3.7433,-0.40215,-1.2953,1”
“0.40614,1.3492,-1.4501,-0.55949,1”
“-1.3887,-4.8773,6.4774,0.34179,1”
“-3.7503,-13.4586,17.5932,-2.7771,1”
266 Machine Learning dengan Python

“-3.5637,-8.3827,12.393,-1.2823,1”
“-2.5419,-0.65804,2.6842,1.1952,1”
Informasi kumpulan data:
Data diambil dari gambar spesimen mirip uang kertas asli dan palsu. Untuk digitalisasi,
digunakan kamera industri yang biasanya digunakan untuk pemeriksaan cetak. Gambar
akhir memiliki 400x400 piksel. Karena lensa objek dan jarak ke objek yang diselidiki,
diperoleh gambar skala abu-abu dengan resolusi sekitar 660 dpi. Alat transformasi
wavelet digunakan untuk mengekstraksi fitur dari gambar.
2. Informasi Data
Data diambil dari ekstraksi gambar yang diambil dari BN. Untuk keperluan digitalisasi,
kamera industri digunakan untuk mencetak inspeksi yang digunakan. Gambar akhir
yang diperoleh 400x400 pixel. Sesuai dengan lensa objek dan jarak pada objek yang
diinvestigasi dalam gambar berwarna abu-abu dengan resolusi 600 dpi. Transformasi
wavelet digunakan untuk mengekstraksi atribut dari gambar berupa:
a. variance of Wavelet Transformed image (continuous).
b. skewness of Wavelet Transformed image (continuous).
c. curtosis of Wavelet Transformed image (continuous).
d. entropy of image (continuous).
e. class (integer).
Akhirnya, kita akan mengimplementasikan Scikit-Learn di mana data dan fungsi-fungsi
(library) perlu diimpor dan membuat analisis dengan membagi data dalam data latih dan
data uji. Setelah itu, melatih algoritma untuk dapat melakukan prediksi dan akhirnya
menggunakan algoritma untuk data.
3. Persiapan Data
Data dipisahkan dengan beberapa tahap:
a. Data dipisahkan atas data atribut/fitur dan data label (target).
X: semua variabel/fitur/atribut yang memuat semua kolom, kecuali kolom Class yang
merupakan kolom label.
Y: variabel yang memuat kolom Class.
Jadi, variabel X adalah himpunan atribut kita, sedangkan y adalah variabel yang
memuat pelabelan.
 Pohon Keputusan (Decision Tree/DT) 267

b. Selanjutnya, data dibedakan menjadi data latih dan data uji di mana kemudian kita
melakukan pemilihan model dengan librari train_test_split. Pada coding tersebut,
parameter yang membedakan himpunan data yang diuji akan dipisahkan menjadi
20% data uji dan 80% data latih. Parameter tersebut adalah test_size=0.20.
4. Membuat Pohon dan Melakukan Prediksi
Pada scikit-learn, terdapat library tree yang memuat kelas/metode yang bervariasi
tentang algoritma Decision Tree. Karena kita akan melakukan klasifikasi maka digunakan
kelas DecisionTreeClassifier. Kemudian gunakan fit untuk melatih algoritma pada data
latih. Setelah klasifikasi dicobakan, kita akan melakukan prediksi pada data uji di mana
kita menggunakan fungsi predict pada DecisionTreeClassifier. Diasumsikan penulis
telah melakukan instalasi librari ini. Jika diinstal pada Anaconda prompt dengan: Conda
install DecisionTreeClassifier maka terjadi error yang menjelaskan bahwa
package not found. Berdasarkan informasi stack overflow maka disarankan penulis untuk
melakukan instalasi pada anaconda dengan perintah:
conda config --append channels conda-forge. Kemudian baru dapat dilakukan
instalasi untuk DecisionTreeClassifier dengan menuliskan pada anaconda prompt, yaitu:
conda install DecisionTreeClassifier.
5. Program Terkait
Kasus di atas dinyatakan dalam program Python.
#https://stackabuse.com/decision-trees-in-python-with-
scikit-learn/
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
get_ipython().run_line_magic(‘matplotlib’, ‘inline’)
dataset = pd.read_csv(‘bill_authentication.csv’)
# In[14]:
dataset.shape # artinya terdapat 1372 baris dengan 5
kolom
# In[15]:
dataset.head() # menampilkan atribut dan klas
268 Machine Learning dengan Python

#Memisahkan data antar atribut (fitur/variabel) dengan

classnya
X = dataset.drop(‘Class’, axis=1)
y = dataset[‘Class’]
Luaran:
#Pemisahan data dari data uji dan data latih
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X,
y, test_size=0.20)
from sklearn.tree import DecisionTreeClassifier
classifier = DecisionTreeClassifier()
classifier.fit(X_train, y_train)
y_pred = classifier.predict(X_test)
print(y_pred)
from sklearn.metrics import classification_report,
confusion_matrix
print(confusion_matrix(y_test, y_pred))
print(classification_report(y_test, y_pred))
#Hasil Luaran CM
[[146 6]
[ 4 119]]
[1 0 0 1 1 1 1 1 0 0 1 0 1 0 0 1 1 0 1 0 0 0 1 0 0 1
0 1 1 0 1 1 1 1 1 0 1
0 0 0 0 1 1 1 1 0 1 1 1 1 1 0 0 1 1 0 1 0 0 0 0 1 0 1
0 0 0 0 0 0 0 0 1 1
0 1 1 1 1 0 0 1 1 0 1 0 0 0 0 1 0 1 0 0 0 0 1 0 1 1 0
0 1 0 1 1 0 0 0 0 0
0 1 0 0 0 1 1 0 0 0 0 1 1 0 0 1 0 1 1 1 0 1 1 1 0 1 0
1 0 0 1 0 0 0 1 1 0
1 0 1 1 0 0 0 1 1 0 0 0 0 0 0 1 0 1 0 1 0 0 1 0 0 1 0
 Pohon Keputusan (Decision Tree/DT) 269

0 1 0 0 1 0 0 0 1 0
0 1 0 1 1 1 0 0 1 1 0 0 1 0 1 1 0 1 1 1 1 1 1 0 0 0 0
0 1 1 0 0 1 0 0 0 0
0 0 1 0 1 1 0 0 0 1 0 1 1 0 0 1 1 1 0 1 0 1 0 1 1 0 0
0 0 1 1 0 1 0 1 0 0
1 1 0 1 1 1 0 0 1 1 0 0 0 1 0 0]
precision recall f1-score support
0 0.97 0.96 0.97 152
1 0.95 0.97 0.96 123
avg / total 0.96 0.96 0.96 275
Dari CM diperoleh 275 luaran ada 10 (total diagonal = 265) yang misklasifikasi ada 10,
total misdiagonal yang berarti 265/275 *100 (%) = 96.36%.
Data diperoleh dari https://drive.google.com/file/d/1mVmGNx6cbfvRHC_DvF12ZL3wGL
SHD9f_/view. Silakan download dengan nama file petrol_consumption.csv.
Referensi data:
# Helmut Spaeth, Mathematical Algorithms for Linear
Regression,
# Academic Press, 1991, ISBN 0-12-656460-4.
# S Weisberg,Applied Linear Regression, New York,
1980, pages 32-33.
Masalah:
Dalam 1 tahun, konsumsi bahan bakar dihitung pada 48 negara bagian. Variabel yang
relevan adalah pajak bahan bakar, pendapatan per kapita, banyaknya panjang jalan tol
yang dilalui (dalam mil), dan proporsi populasi pengendara yang berlisensi. Data terdiri
dari 48 baris yang meliputi:
# I, indeks,
# A0, 1;
# A1, the petrol tax (pajak per galon untuk
petroleum)
# A2, the per capita income (pendapatan per
kapita)
270 Machine Learning dengan Python

# A3, the number of miles of paved highway

(jumlah mil yang ditempuh di tol)
# A4, the proportion of drivers (proporsi
banyaknya pengemudi)
# B, the consumption of petrol (konsumsi
petroleum/bahan bakar yang digunakan)
# Kita mencari model dalam bentuk
# B = A0 * X0 + A1 * X1 + A2 * X2 + A3 * X3 + A4
* X4.
Data ini digunakan untuk menduga konsumsi gas (dalam berjuta galon) dalam 48 negara
bagian Amerika berdasarkan pajak gas (dalam cent), pendapatan per kapita (dalam dolar),
jumlah mil yang ditempuh di tol, proporsi banyaknya pengemudi. Script ini merupakan
contoh implementasi Decision Tree Regression menggunakan library scikit-learn pada
bahasa pemrograman Python.
Pada script berikut, dataset yang digunakan adalah petrol_consumption.csv yang berisi
data tentang konsumsi bensin per kapita di beberapa negara dengan atribut seperti
populasi, jumlah kendaraan yang beroperasi, pendapatan per kapita, dan persentase
penduduk kota. Tujuan dari model ini adalah untuk memprediksi konsumsi bensin
berdasarkan atribut-atribut tersebut.
Pertama-tama, dataset dibagi menjadi atribut (X) dan label (y) menggunakan metode
drop() pada pandas. Kemudian, dataset dibagi menjadi training set dan testing
set dengan perbandingan 80:20 menggunakan train_test_split() pada scikit-learn.
Selanjutnya, DecisionTreeRegressor() pada scikit-learn digunakan untuk membuat objek
model Decision Tree Regression. Model tersebut dilatih menggunakan metode fit() pada
training set yang telah dibagi sebelumnya. Kemudian, model tersebut digunakan untuk
memprediksi konsumsi bensin pada testing set dengan menggunakan metode predict().
Terakhir, performa model diukur dengan menggunakan metrik Mean Squared Error
(MSE) dan Coefficient of Determination (R-Squared) dengan mengimpor mean_squared_
error() dan r2_score() dari scikit-learn. Hasil performa model tersebut dicetak dengan
menggunakan fungsi print().
 Pohon Keputusan (Decision Tree/DT) 271

Program:
# Import library yang dibutuhkan
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeRegressor
from sklearn.metrics import mean_squared_error, r2_score

# Load dataset
dataset = pd.read_csv(‘petrol_consumption.csv’)

# Pisahkan antara atribut dan label

X = dataset.drop(‘Petrol_Consumption’, axis=1)
y = dataset[‘Petrol_Consumption’]

# Bagi dataset menjadi training set dan testing set

X_train, X_test, y_train, y_test = train_test_
split(X, y, test_size=0.2, random_state=0)

# Buat objek DecisionTreeRegressor

regressor = DecisionTreeRegressor()

# Latih model menggunakan training set

regressor.fit(X_train, y_train)

# Prediksi nilai konsumsi bensin menggunakan testing set

y_pred = regressor.predict(X_test)

# Evaluasi performa model menggunakan metrik Mean Squared

Error dan Coefficient of Determination (R-Squared)
272 Machine Learning dengan Python

mse = mean_squared_error(y_test, y_pred)

r2 = r2_score(y_test, y_pred)
print(‘Mean Squared Error:’, mse)
print(‘R-Squared:’, r2)
# Evaluate the model
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
print(“Root Mean Squared Error:”, rmse)

Luaran Program :
# Import library yang dibutuhkan
Mean Squared Error: 5352.5
R-Squared: 0.08651680024029607
Root Mean Squared Error: 73.16078184382668

Catatan:
Pada kode X = dataset.drop(‘Petrol_Consumption’, axis=1), axis=1 berarti kita menghapus
kolom dari dataset, bukan baris. Lebih spesifiknya, kolom yang dihapus adalah ‘Petrol_
Consumption’. Jadi, X akan berisi dataset yang sama dengan dataset, namun tanpa
kolom ‘Petrol_Consumption’. Secara umum, axis=1 digunakan untuk mengacu pada
dimensi kolom dari sebuah array atau dataframe di Python. Adapun hasil decision tree
secara grafik seperti pada Gambar 5.3.
 Pohon Keputusan (Decision Tree/DT) 273

Gambar 5.3 Sketsa decision tree yang diperoleh (hasil kode penulisan tidak cukup jelas)
274 Machine Learning dengan Python

5.3.3. Membuat Code Decision Tree dari Awal

Pada bagian ini, kita akan buat Decision Tree dari awal dengan formula di mana kasus yang
kita pelajari adalah petroleum_consumption.csv.
import numpy as np
import pandas as pd

import os

# Mount your Google Drive to access files stored there

from google.colab import drive
drive.mount(‘/content/drive’)

# Merubah directory

os.chdir(‘/content/drive/MyDrive/….’) #folder dimana

data disimpan
data = pd.read_csv(‘petrol_consumption.csv’)

# Memisahkan data antara label dan fitur (X)

X = data.drop(‘Petrol_Consumption’, axis=1).values
y = data[‘Petrol_Consumption’].values

class DecisionTree:
def __init__(self, max_depth=None):
self.max_depth = max_depth

def fit(self, X, y):

self.n_classes_ = len(np.unique(y))
self.n_features_ = X.shape[1]
self.tree_ = self._grow_tree(X, y)
 Pohon Keputusan (Decision Tree/DT) 275

def _grow_tree(self, X, y, depth=0):

n_samples, n_features = X.shape
n_labels = len(np.unique(y))

# Hentikan jika salah satu dari kondisi di

bawah ini dipenuhi
# - maximum depth tercapai
# - hanya 1 label yang tersisa
# - hanya 1 fitur yang tersisa
if (self.max_depth is not None and depth >=
self.max_depth) or n_labels == 1 or n_features == 1:
return Node(label=self._most_common_
label(y))

# Tentukan fitur terbaik dan titik pemisah

feature, threshold = self._best_split(X, y)

# Pisahkan data
left_idxs = X[:, feature] < threshold
right_idxs = ~left_idxs
left_tree = self._grow_tree(X[left_idxs],
y[left_idxs], depth+1)
right_tree = self._grow_tree(X[right_idxs],
y[right_idxs], depth+1)

returnNode(feature=feature,threshold=threshold,left_
tree=left_tree,right_tree=right_tree)
def _best_split(self, X, y):
# Hitung ketidakmurnian Gini (Gini impurity)
untuk setiap fitur dan buatlah titik pemisahan
276 Machine Learning dengan Python

best_feature = None
best_threshold = None
best_gini = 1

for feature in range(self.n_features_):

thresholds = np.unique(X[:, feature])
for threshold in thresholds:
left_idxs = X[:, feature] < threshold
right_idxs = ~left_idxs
gini = (left_idxs.sum() * self._
gini(y[left_idxs]) +
right_idxs.sum() * self._
gini(y[right_idxs])) / len(y)
if gini < best_gini:
best_feature = feature
best_threshold = threshold
best_gini = gini

return best_feature, best_threshold

def _gini(self, y):

_, counts = np.unique(y, return_counts=True)
proportions = counts / len(y)
return 1 - np.sum(proportions**2)

def _most_common_label(self, y):

_, counts = np.unique(y, return_counts=True)
return np.argmax(counts)
 Pohon Keputusan (Decision Tree/DT) 277

def predict(self, X):

return [self._predict(inputs) for inputs in X]

def _predict(self, inputs):

node = self.tree_
while node.feature is not None:
if inputs[node.feature] < node.threshold:
node = node.left_tree
else:
node = node.right_tree
return node.label

class Node:
def __init__(self, feature=None, threshold=None,
label=None, left_tree=None, right_tree=None):
self.feature = feature
self.threshold = threshold
self.label = label
self.left_tree = left_tree
self.right_tree = right_tree

tree = DecisionTree(max_depth=5)
tree.fit(X, y)

from sklearn.tree import DecisionTreeClassifier

from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
import pandas as pd
278 Machine Learning dengan Python

# Load the dataset

data = pd.read_csv(‘petrol_consumption.csv’)

# Pisahkan data latih dan data uji

X = data.drop(‘Petrol_Consumption’, axis=1)
y = data[‘Petrol_Consumption’].values
X_train, X_test, y_train, y_test = train_test_split(X,
y, test_size=0.2)

# Fit a decision tree classifier

clf = DecisionTreeClassifier()
clf.fit(X_train, y_train)
clf.fit(X_train, y_train)
# Buat prediksi
predictions = clf.predict(X_test)

# Evaluasi akurasinya
accuracy = accuracy_score(y_test, predictions)
print(“Accuracy:”, accuracy)
#Menampilkan tree
from sklearn.tree import DecisionTreeClassifier, plot_
tree
import matplotlib.pyplot as plt
# Visualize the decision tree
plt.figure(figsize=(10,10))
plot_tree(clf, filled=True)
plt.show()
 Pohon Keputusan (Decision Tree/DT) 279

5.3.4. Analisis Lebih Lanjut dengan Decision Tree

Dalam konteks dataset petroleum_consumption.csv dan pengklasifikasi pohon keputusan,
target_names adalah daftar nama kelas yang sesuai dengan variabel target Petroleum_
Consumption dalam dataset. Dalam dataset ini, Petroleum_Consumption adalah variabel
kontinu yang mewakili konsumsi minyak tahunan per kapita di suatu negara. Untuk
menggunakan variabel ini sebagai variabel target untuk pengklasifikasi pohon keputusan, kita
perlu mendiskritisasinya menjadi variabel kategorikal dengan jumlah kelas yang tetap. Dalam
kode contoh, variabel Petroleum_Consumption didiskritisasi menjadi tiga kelas berdasarkan
rentang berikut:
Rendah: 0-5.000 barel per kapita
Sedang: 5.000-10.000 barel per kapita
Tinggi: >10.000 barel per kapita
Penjelasan beberapa bagian dalam kode di atas ditunjukkan pada tabel berikut.
def _most_common_label(self, y):
_, counts = np.unique(y, return_counts=True)
return np.argmax(counts)
Fungsi ini akan menghitung berapa kali setiap label muncul dalam array y, menggunakan
fungsi np.unique() dari pustaka NumPy. Fungsi np.unique() mengembalikan dua nilai: array
yang berisi nilai unik dari array input, dan array yang berisi jumlah kemunculan setiap nilai unik.
Fungsi _most_common_label() kemudian mengambil array yang berisi jumlah kemunculan
setiap nilai unik yang dihasilkan oleh np.unique(), dan mengembalikan indeks nilai maksimum
dalam array tersebut menggunakan fungsi np.argmax(). Nilai indeks maksimum ini kemudian
digunakan untuk mengambil nilai label yang paling umum atau sering muncul dalam array
y. Jadi, secara keseluruhan, fungsi ini digunakan untuk menghitung label yang paling sering
muncul dalam array y, yang nantinya dapat digunakan sebagai prediksi atau hasil dari sebuah
model klasifikasi.
def _gini(self, y):
_, counts = np.unique(y, return_counts=True)
proportions = counts / len(y)
return 1 - np.sum(proportions**2)
280 Machine Learning dengan Python

Fungsi ini menghitung koefisien gini impurity dari array y yang digunakan dalam algoritma
pohon keputusan untuk memilih fitur terbaik pemisahan data. Gini impurity mengukur seberapa
campur aduk label dalam sebuah set data. Semakin homogen (tidak campur aduk) suatu set
data maka semakin rendah nilai gini impurity-nya. Pertama, fungsi ini menggunakan fungsi
np.unique() dari pustaka NumPy untuk menghitung jumlah kemunculan setiap nilai unik
dalam array y. Kemudian, fungsi ini menghitung proporsi kemunculan setiap nilai unik dengan
membagi jumlah kemunculannya dengan panjang array y. Selanjutnya, fungsi ini menghitung
gini impurity dari array y dengan menggunakan formula:

gini = 1 - sum(proportions**2)

Di mana proportions adalah array yang berisi proporsi kemunculan setiap nilai unik yang
telah dihitung sebelumnya. Kode ini mengembalikan nilai koefisien gini impurity dari array y.
Semakin rendah nilai gini impurity, semakin homogen (tidak campur aduk) set data tersebut,
dan semakin baik digunakan dalam pemilihan fitur terbaik pada algoritma pohon keputusan.

5.4. Random Forest

Random Forest adalah teknik komputasi yang efisien yang dapat beroperasi dengan cepat
pada kumpulan data besar. Teknik ini telah digunakan dalam banyak proyek penelitian
terbaru dan aplikasi dunia nyata di berbagai domain. Namun, literatur terkait hampir tidak
memberikan arahan tentang berapa banyak pohon yang harus digunakan untuk menyusun
Hutan Acak. Penelitian yang dilaporkan di sini menganalisis apakah ada jumlah pohon yang
optimal dalam Hutan Acak, yaitu, ambang batas di mana peningkatan jumlah pohon tidak
akan memberikan keuntungan kinerja yang signifikan, dan hanya akan meningkatkan biaya
komputasi. Kesimpulan utama yang diperoleh adalah seiring bertambahnya jumlah pohon,
tidak selalu berarti kinerja hutan secara signifikan lebih baik dari hutan sebelumnya (lebih
sedikit pohon), dan menggandakan jumlah pohon tidak ada gunanya. Dimungkinkan juga untuk
menyatakan bahwa ada ambang batas yang di luarnya tidak ada keuntungan yang signifikan,
kecuali tersedia lingkungan komputasi yang sangat besar. Selain itu, ditemukan hubungan
eksperimental untuk perolehan AUC saat menggandakan jumlah pohon di hutan mana pun.
Bagian ini berisi pengantar singkat tentang konsep ensemble estimator, dan khususnya
ensemble random forest. Random forest adalah metode yang ampuh dengan beberapa
keunggulan:
 Pohon Keputusan (Decision Tree/DT) 281

1. Pelatihan (training) dan prediksi keduanya sangat cepat karena kesederhanaan decision
tree yang mendasarinya. Selain itu, kedua tugas dapat langsung diparalelkan karena
masing-masing pohon merupakan entitas yang sepenuhnya independen.
2. Beberapa pohon memungkinkan untuk klasifikasi probabilistik: suara mayoritas di antara
penaksir memberikan perkiraan probabilitas (diakses di Scikit-Learn dengan metode
predict_proba()).
3. Model nonparametrik sangat fleksibel, dan dengan demikian dapat bekerja dengan baik
pada tugas-tugas yang kurang sesuai dengan estimator lainnya.
Kerugian utama dari random forest adalah bahwa hasilnya tidak mudah ditafsirkan, yaitu
jika kita ingin menarik kesimpulan tentang arti model klasifikasi, random forest mungkin bukan
pilihan terbaik. Kita akan menggunakan Random Forest untuk kasus yang sama di atas.
Program:
#RANDOM FOREST
# Import library
import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestRegressor

# Panggil data : dataset

dataset = pd.read_csv(‘petrol_consumption.csv’)

# Pisahkan fitur dan variabel target (label)

X = dataset.drop(‘Petrol_Consumption’, axis=1)
y = dataset[‘Petrol_Consumption’]

# Pemisahan data training dan data test

X_train, X_test, y_train, y_test = train_test_
split(X, y, test_size=0.2,
random_state=42)
282 Machine Learning dengan Python

# Buat model Random Forest

rf_model = RandomForestRegressor(n_
estimators=100, random_state=42)

# Lakukan pelatihan model

rf_model.fit(X_train, y_train)

# Buat prediksi
y_pred = rf_model.predict(X_test)

# Evaluasi model
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
print(“Root Mean Squared Error:”, rmse)

Luaran : Root Mean Squared Error: 82.67682014930183

Pembahasan :
Terlihat bahwa Random Forest memberikan hasil yang
lebih baik.

Beberapa keterangan yang mungkin diperlukan bagi pembaca:

random_state adalah parameter yang digunakan untuk menentukan nilai seed dalam proses
randomization pada pemilihan sampel acak (random sampling) dan inisialisasi model yang
menggunakan komponen acak. Jadi, jika kita menentukan nilai random_state yang sama
maka model akan di inisialisasi dengan nilai yang sama setiap kali kita menjalankan kode
tersebut.
Ada penjelasan menarik mengapa random seed=42 pada internet:
Dalam novel fiksi ilmiah populer tahun 1979 karya Douglas Adams, The Hitchhiker’s Guide
to the Galaxy, menjelang akhir buku, superkomputer Deep Thought mengungkapkan bahwa
jawaban atas pertanyaan besar tentang “kehidupan, alam semesta, dan segalanya” adalah 42.
 Pohon Keputusan (Decision Tree/DT) 283

Pilihan nomor 42 Adams telah menjadi perlengkapan budaya geek. Budaya geek adalah
sebuah subkultur yang menekankan pada minat dan kesukaan pada topik-topik yang dianggap
khas atau geeky, seperti teknologi, video game, komik, film fiksi ilmiah, dan acara televisi,
serta ilmu pengetahuan dan matematika. Orang-orang yang terlibat dalam budaya geek sering
memiliki minat yang mendalam dan pengetahuan yang luas dalam topik-topik ini, dan mereka
sering terlibat dalam aktivitas, seperti pengumpulan merchandise, cosplay, atau pertemuan
dan konvensi yang berkaitan dengan topik-topik ini. Budaya geek telah menjadi sangat populer
dalam beberapa dekade terakhir, terutama dengan munculnya teknologi dan media baru yang
menarik minat orang untuk terlibat dalam komunitas ini. Orang menemukan humor di dalamnya,
dan beberapa karena menghormati literatur sci-fi klasik menggunakan 42 di berbagai tempat.
Ada banyak teori dari penggemar untuk menjelaskan mengapa nomor 42 dipilih.
Beberapa mengusulkan bahwa itu dipilih karena 42 adalah 101010 dalam kode biner,
yang lain menunjukkan bahwa cahaya dibiaskan melalui permukaan air sebesar 42 derajat
untuk menciptakan pelangi. Adapula yang berkomentar bahwa cahaya membutuhkan 10 ⁴²
detik untuk melintasi diameter proton. Namun yang lain mengatakan bahwa 42 adalah
penghargaan Adams untuk buku paperback yang tak kenal lelah, dan merupakan jumlah baris
rata-rata pada halaman rata-rata dari paperback rata-rata. Teori umum lainnya adalah bahwa
42 mengacu pada jumlah hukum dalam kriket, tema yang berulang dari buku. Namun, Douglas
Adams sendiri membeberkan alasan mengapa ia memilih 42 dalam pesan tersebut. “Itu adalah
lelucon. Itu harus berupa angka, angka biasa yang kecil, dan saya memilih yang itu. Saya
duduk di meja saya, menatap ke taman dan berpikir 42 sudah cukup!”
284 Machine Learning dengan Python

DAFTAR PUSTAKA
Beschi Raja, J., Anitha, R., Sujatha, R., Roopa, V., & Sam Peter, S. 2019. Diabetics Prediction
using Gradient Boosted Classifier. International Journal of Engineering and Advanced
Technology, 9 (1), 3181–3183. https://doi.org/10.35940/ijeat.A9898.109119.
Carterette, B. 2011. Precision and Recall. In Encyclopedia of Machine Learning (pp. 1–2).
Springer Boston. https://doi.org/10.1007/978-1-4899-7993-3_5050-2.
Kelleher, B. J. D., & Brendan, T. 2018. Data Science. The MIT Press. https://mitpress.mit.
edu/9780262535434/data-science/.
Provost & Fawcett. 2013. Data Science for Business : What You Need to Know about Analytic-
Thinking and Decision-Making (Vol. 53, Issue 9).
Zhang, L., Qi, Z., & Meng, F. 2021. A Review on the Construction of Business Intelligence
System Based on Unstructured Image Data. Procedia Computer Science, 199, 392–
398. https://doi.org/10.1016/j.procs.2022.01.048.
https://www.datacamp.com/tutorial/decision-tree-classification-python.
BAB 6
MACHINE LEARNING UNTUK
KASUS COVID-19

Virus Corona atau Severe Acute Respiratory Syndrome Coronavirus 2 (SARS-CoV-2) adalah
virus yang menyerang sistem pernapasan. Infeksi virus ini disebut Covid-19 dan pertama kali
ditemukan di kota Wuhan, Cina, pada akhir Desember 2019. Secara umum, ada 3 gejala
umum yang bisa menandakan seseorang terinfeksi virus Corona, yaitu demam (suhu tubuh
di atas 38 derajat Celsius), batuk, dan sesak napas. Pada bagian ini, akan digunakan data
Covid-19 yang diambil dari berbagai sumber internet, di mana data tersebut merupakan
data yang berisi informasi harian tentang jumlah kasus Covid-19, baik daerah lokal, provinsi,
Indonesia, dan data dari berbagai kota berpengaruh di dunia. Salah satu pembahasan yang
telah dilakukan pada awal wabah Covid-19 adalah penggunaan SVR dalam melakukan regresi
terhadap jumlah kasus Covid-19 (Parhusip, 2020).
Pada buku ini, kita akan menelusuri data kasus Covid-19 kembali. Dari data tersebut,
akan dibuat plot dalam membaca data dan memberikan ilustrasi grafik untuk beberapa kasus
sehingga terdapat informasi yang mungkin diperlukan para pengambil keputusan saat terjadinya
data berlangsung. Program untuk mengolah data dengan Machine Learning ini dibuat tahun
2020 ketika Covid-19 sedang mulai terjadi sehingga data tentunya ter-update sesuai sumber
data. Pada bagian ini, ditunjukkan bagaimana kita dapat melakukan pembacaan data dan
sedikit melakukan analisis dengan Machine Learning. Program Python yang dikerjakan pada
Colab sehingga dapat mempermudah pembaca tanpa menggunakan instalasi Python pada
komputer lokal.
286 Machine Learning dengan Python

6.1. Data Covid-19 di Salatiga pada 30 Maret-7 November 2020

Kasus Sederhana
Pada bagian ini, kita akan belajar dengan data sederhana terlebih dahulu untuk dapat
menggunakan Python.
Tahap 1. Kita akan gunakan data kasus Covid-19 di Salatiga yang disimpan pada file
Salatiga_30Maret_7November.csv
Jangan lupa untuk membaca dengan Colab maka perlu mounting drive untuk merujuk folder
pada drive yang dituju dengan perintah:
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from google.colab import drive
drive.mount(“/content/drive”)
#https://medium.com/@nyla.pirani/how-to-build-a-basic-
breast-cancer-model-machine-learning-9bae53c40f18
#import fungsi/librari yang digunakan
dataset = pd.read_csv(‘/content/drive/My Drive/
CORONANEWS/CORONAINDO_perMaret2020/DATA_COVID_MHS/
Salatiga_30Maret_7November.csv’)
Perhatikan bahwa lokasi data perlu disesuaikan di mana data Anda ditempatkan pada Google
Drive.
Tahap 2. Seperti pada umumnya, cek apakah data terbaca dengan melihat data bagian atas
dan bagian bawah
dataset.head()
dataset.tail()
 Machine Learning untuk Kasus Covid-19 287

Luaran:

Pada bagian bawah terlihat sebagai berikut:

Pembahasan: Jadi, data telah terbaca di mana data dari tanggal 30 Maret 2020 hingga 7
November 2020. Terdapat 4 fitur, yaitu Suspek (Rentan), Terkonfirmasi, Sembuh, dan
Meninggal.
Tahap 3. Menampilkan data secara deskriptif
Kita dapat menggunakan perintah:
dataset.describe()

Penampilan data lebih menarik untuk digambar. Kita dapat menggunakan mathplotlib.
288 Machine Learning dengan Python

Tahap 4. Kita menggambarkan fitur ‘Suspek(rentan)’

# Gambar
fig, ax = plt.subplots(figsize=(10, 10))

# Tambahkan sumbu-x dan sumbu-y

ax.plot(dataset[‘Tanggal’],
dataset[‘Suspek (Rentan)’],
color=’purple’)

# Tambahkan judul dan label

ax.set(xlabel=”Tanggal”,
ylabel=”Suspek (Rentan)”,
title=”Kasus Covid-19 Salatiga :Suspek (Rentan)
30 Maret-7 November 2020»)

Gambar 6.1 Tampilan data kasus Covid-19 di Salatiga untuk fitur ‘Suspek (rentan)’ pada periode 30
Maret-7 November 2020
 Machine Learning untuk Kasus Covid-19 289

Pada Gambar 6.1, sumbu tanggal tidak tampil dengan baik sehingga kita perlu menata tampilan
untuk sumbu horizontal. Untuk itu, data Tanggal akan diganti dengan indeks, sebagaimana
perintah berikut ini.
#menjadikan data tanggal menjadi indeks
index_col = [‘Tanggal’]
Luaran ditunjukkan pada Gambar 6.2.
Tahap 5a

import matplotlib.pyplot as pls

#dataset.
plot(x=’Tanggal’, y=’Terkonfirmasi’, kind=’bar’)
# plotting the points
dataset.
plot(x=’Tanggal’, y=’Terkonfirmasi’,color=’green’,
linestyle=’dashed’, linewidth = 3,marker=’o’,
markerfacecolor=’blue’, markersize=4)
plt.show()

Tahap 5b Misalkan digunakan data fitur ‘Terkonfirmasi’

# buat
fig, ax = plt.subplots(figsize=(10, 10))

# Tambahkan aturan sumbu x dan sumbu y

ax.scatter(dataset.index.values,
dataset[‘Terkonfirmasi’],
color=’purple’)
# Buat judul dan nama sumbu
ax.set(xlabel=”Tanggal”,
ylabel=”Terkonfirmasi”,
title=”Total kumulatifTerkonfirmasi Salatiga 30
Maret-7 November 2020»)
plt.show()
290 Machine Learning dengan Python

Luaran ditunjukkan pada Gambar 6.2.

Gambar 6.2 Tampilan data kasus Covid-19 di Salatiga untuk fitur ‘Terkonfirmasi’ pada periode 30
Maret-7 November 2020

Gambar 6.3 Tampilan data kasus Covid-19 di Salatiga untuk fitur ‘Terkonfirmasi’ pada periode 30
Maret-7 November 2020
 Machine Learning untuk Kasus Covid-19 291

Tahap 6. Menggambarkan beberapa fitur dalam satu gambar

dataset.plot(x=’Tanggal’, y=[“Terkonfirmasi”, “Sembuh”,

“Meninggal”],color=[‘green’,’yellow’,’red’], linestyle=
’dashed’, linewidth = 1,marker=’o’, markerfacecolor=
’blue’, markersize=4)

Ditunjukkan pada Gambar 6.4.

Gambar 6.4 Tampilan data kasus Covid-19 di Salatiga untuk fitur ‘Terkonfirmasi’, ‘Sembuh’, dan
‘Meninggal’ pada periode 30 Maret-7 November 2020

Tahap 7.

dataset.plot(x=’Tanggal’, y=’Meninggal’,color=’green’,
linestyle=’dashed’, linewidth = 1,marker=’o’,
markerfacecolor=’blue’, markersize=4)
292 Machine Learning dengan Python

Luaran ditunjukkan pada Gambar 6.5.

Gambar 6.5 Tampilan data kasus Covid-19 di Salatiga untuk fitur ‘Meninggal’ pada periode 30 Maret-7
November 2020

Tahap 8. Menggambar 6 dengan 3 fitur

dataset.plot(‘Tanggal’,[‘Terkonfirmasi’,’Sembuh’,
’Meninggal’],figsize=(10,10), rot=30)

Gambar 6.6 Tampilan data kasus Covid-19 di Salatiga untuk fitur ‘Meninggal’ pada periode 30 Maret-7
November 2020
 Machine Learning untuk Kasus Covid-19 293

Sejauh ini, kita hanya menggambar data. Kita akan menggunakan data yang lebih kompleks,
yaitu data Covid-19 Indonesia dengan sedikit melakukan analisis berdasarkan visualisasi yang
diperoleh.

6.2. Machine Learning Data Kasus Covid-19 Indonesia

File data: DataCovid-19.xlsx
Sebagaimana biasanya, kita akan menjelaskan tahap demi tahap agar pembaca dapat
melakukan program ini kembali secara mandiri. Perhatikan bahwa program dijalankan pada
Colaboratory sehingga perlu mounting drive.
Tahap 1. Tahap panggil librari yang dikehendaki dan panggil data
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

from google.colab import drive

drive.mount(“/content/drive”)
covid = pd.read_excel(“/content/drive/My Drive/
CORONANEWS/CORONAINDO_perMaret2020/DATA_COVID_MHS/
DataCovid-19.xlsx”)
covid
Gambar 6.7 Tampilan data yang akan diolah (kasus Covid-19 hingga 2 Desember 2021) sebanyak 21759 rows × 38 columns
 Machine Learning untuk Kasus Covid-19 295

Tahap 2. Pelajari data (komponen data)

> covid.info()
Luaran:
<class ‘pandas.core.frame.DataFrame’>
RangeIndex: 21759 entries, 0 to 21758
Data columns (total 38 columns):
# Column Non-Null Count
Dtype
--- ------ -------------- ---
--
0 Date 21759 non-null
datetime64[ns]
1 Location ISO Code 21759 non-null
object
2 Location 21759 non-null
object
3 New Cases 21759 non-null
int64
4 New Deaths 21759 non-null
int64
5 New Recovered 21759 non-null
int64
6 New Active Cases 21759 non-null
int64
7 Total Cases 21759 non-null
int64
8 Total Deaths 21759 non-null
int64
9 Total Recovered 21759 non-null
int64
10 Total Active Cases 21759 non-null
296 Machine Learning dengan Python

int64
11 Location Level 21759 non-null
object
12 City or Regency 0 non-null
float64
13 Province 21117 non-null
object
14 Country 21759 non-null
object
15 Continent 21759 non-null
object
16 Island 21117 non-null
object
17 Time Zone 21117 non-null
object
18 Special Status 3123 non-null
object
19 Total Regencies 21759 non-null
int64
20 Total Cities 21145 non-null
float64
21 Total Districts 21759 non-null
int64
22 Total Urban Villages 21142 non-null
float64
23 Total Rural Villages 21117 non-null
float64
24 Area (km2) 21759 non-null
int64
25 Population 21759 non-null
int64
26 Population Density 21759 non-null
 Machine Learning untuk Kasus Covid-19 297

float64
27 Longitude 21759 non-null
float64
28 Latitude 21759 non-null
float64
29 New Cases per Million 21759 non-null
float64
30 Total Cases per Million 21759 non-null
float64
31 New Deaths per Million 21759 non-null
float64
32 Total Deaths per Million 21759 non-null
float64
33 Total Deaths per 100rb 21759 non-null
float64
34 Case Fatality Rate 21759 non-null
float64
35 Case Recovered Rate 21759 non-null
float64
36 Growth Factor of New Cases 20572 non-null
float64
37 Growth Factor of New Deaths 19292 non-null
float64
dtypes: datetime64[ns](1), float64(16), int64(12),
object(9)
memory usage: 6.3+ MB
CodeText
Pembahasan: Dari hasil luaran ini terlihat banyaknya fitur adalah 37.
298 Machine Learning dengan Python

Tahap 3. Memilih fitur yang tidak sesuai

#hilangkan kolom yang datanya tidak lengkap
del covid[“City or Regency”]
del covid[“Province”]
del covid[“Island”]
del covid[“Time Zone”]
del covid[“Special Status”]
del covid[“Total Cities”]
del covid[“Total Urban Villages”]
del covid[“Total Rural Villages”]
del covid[“Growth Factor of New Cases”]
del covid[“Growth Factor of New Deaths”]
Anda dapat menampilkan hasil kembali dengan memanggil
Covid
Selanjutnya, terlihat bahwa banyaknya kolom berkurang, tertulis 21759 rows × 28 columns.
Tahap 4. Kita melakukan ubah tipe tanggal
#mengubah tipe tanggal
from datetime import datetime as dt
from datetime import timedelta
covid.info()

covid_tanggal = pd.to_datetime(covid[“Date”])
Luaran:
<class ‘pandas.core.frame.DataFrame’>
RangeIndex: 21759 entries, 0 to 21758
Data columns (total 28 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 Date 21759 non-null
datetime64[ns]
 Machine Learning untuk Kasus Covid-19 299

1 Location ISO Code 21759 non-null object

2 Location 21759 non-null object
3 New Cases 21759 non-null int64
4 New Deaths 21759 non-null int64
5 New Recovered 21759 non-null int64
6 New Active Cases 21759 non-null int64
7 Total Cases 21759 non-null int64
8 Total Deaths 21759 non-null int64
9 Total Recovered 21759 non-null int64
10 Total Active Cases 21759 non-null int64
11 Location Level 21759 non-null object
12 Country 21759 non-null object
13 Continent 21759 non-null object
14 Total Regencies 21759 non-null int64
15 Total Districts 21759 non-null int64
16 Area (km2) 21759 non-null int64
17 Population 21759 non-null int64
18 Population Density 21759 non-null float64
19 Longitude 21759 non-null float64
20 Latitude 21759 non-null float64
21 New Cases per Million 21759 non-null float64
22 Total Cases per Million 21759 non-null float64
23 New Deaths per Million 21759 non-null float64
24 Total Deaths per Million 21759 non-null float64
25 Total Deaths per 100rb 21759 non-null float64
26 Case Fatality Rate 21759 non-null float64
27 Case Recovered Rate 21759 non-null float64
dtypes: datetime64[ns](1), float64(10), int64(12),
object(5)
memory usage: 4.6+ MB
300 Machine Learning dengan Python

Tahap 5. Memperhatikan lokasi mana saja yang dianalisis karena ada provinsi Indonesia yang
tidak mewakili provinsi mana pun maka data dari Indonesia perlu dihapus
covid[“Location”].unique()

array([‘Aceh’, ‘Bali’, ‘Banten’, ‘Bengkulu’, ‘Daerah

Istimewa Yogyakarta’,
‘DKI Jakarta’, ‘Gorontalo’, ‘Indonesia’,
‘Jambi’, ‘Jawa Barat’,
‘Jawa Tengah’, ‘Jawa Timur’, ‘Kalimantan
Barat’,
‘Kalimantan Selatan’, ‘Kalimantan Tengah’,
‘Kalimantan Timur’,
‘Kalimantan Utara’, ‘Kepulauan Bangka
Belitung’, ‘Kepulauan Riau’,
‘Lampung’, ‘Maluku’, ‘Maluku Utara’, ‘Nusa
Tenggara Barat’,
‘Nusa Tenggara Timur’, ‘Papua’, ‘Papua Barat’,
‘Riau’,
‘Sulawesi Barat’, ‘Sulawesi Selatan’, ‘Sulawesi
Tengah’,
‘Sulawesi Tenggara’, ‘Sulawesi Utara’,
‘Sumatera Barat’,
‘Sumatera Selatan’, ‘Sumatera Utara’],
dtype=object)

Tahap 6. Kita melakukan grouping data dengan 4 fitur berdasarkan per daerahnya
gruping = covid.groupby([“Location”,”Date”]).
agg({“Total Cases”:’sum’,”Total Deaths”:’sum’,
”Total Recovered”:’sum’,”Total Active Cases”:’sum’})
gruping
 Machine Learning untuk Kasus Covid-19 301

Luaran:

Total Total Total Active

Total Cases
Deaths Recovered Cases
Location Date
Aceh 2020-03-26 1 0 0 1
2020-03-27 4 0 0 4
2020-03-28 5 0 0 5
2020-03-29 5 0 0 5
2020-03-30 5 0 0 5
... ... ... ... ... ...
Sumatra 2021-11-28 106030 2889 103045 96
Utara 2021-11-29 106036 2889 103050 97
2021-11-30 106037 2889 103059 89
2021-12-01 106041 2889 103060 92
2021-12-02 106045 2889 103061 95

21759 rows × 4 columns

gruping_location = gruping.drop(“Indonesia”, axis=0)

gruping_location
302 Machine Learning dengan Python

Luaran:

Tahap 7. Lakukan analisis berdasarkan Tanggal

datewise = covid.groupby([“Date”]).
agg({“Total Cases”:’sum’,”Total Deaths”:’sum’,
”Total Recovered”:’sum’, “Total Active Cases”:’sum’})
datewise_harian = datewise.index-datewise.index.min()
datewise
 Machine Learning untuk Kasus Covid-19 303

Tahap 8. Kita akan melihat total kasus berdasarkan lokasi

print(“Total lokasi berdasarkan provinsi:”,
len(covid[“Location”].unique()))
print(“Total data terkonfirmasi:”, datewise
[“Total Cases”].iloc[-1])
print(“Total data sembuh:”, datewise
[“Total Recovered”].iloc[-1])
print(“Total data meninggal:”, datewise
[“Total Deaths”].iloc[-1])
print(“Total kasus aktif:”, datewise
[“Total Active Cases”].iloc[-1])
print(“Total kasus selesai:”, datewise
[“Total Recovered”].iloc[-1]+datewise[“Total Deaths”].
304 Machine Learning dengan Python

iloc[-1])
print(“Aproksima dari kasus terkonfirma-
si per hari:”, np.round(datewise[“Total Cases”].iloc
[-1]/datewise.shape[0]))
print(“Aproksima dari kasus sembuh per hari:”, np.
round(datewise[“Total Recovered”].iloc[-1]/datewise.
shape[0]))
print(“Aproksima dari kasus meninggal per hari:”, np.
round(datewise[“Total Deaths”].iloc[-1]/datewise.
shape[0]))
print(“Aproksima dari kasus terkonfirma-
si per jam:”, np.round(datewise[“Total Cases”].iloc
[-1]/(datewise.shape[0]*24)))
print(“Aproksima dari kasus sembuh per jam:”, np.
round(datewise[“Total Recovered”].iloc[-1]/(datewise.
shape[0]*24)))
print(“Aproksima dari kasus meninggal per jam:”, np.
round(datewise[“Total Deaths”].iloc[-1]/(datewise.
shape[0]*24)))
print(“Kasus terkonfirmasi 24 jam terakh-
ir:”, datewise[“Total Cases”].iloc[-1]-datewise
[“Total Cases”].iloc[-2]) #terjadi penurunan kasus
print(“Kasus sembuh 24 jam terakhir:”, datewise
[“Total Recovered”].iloc[-1]-datewise
[“Total Recovered”].iloc[-2])
print(“Kasus meninggal 24 jam terakhir:”, datewise
[“Total Deaths”].iloc[-1]-datewise[“Total Deaths”].
iloc[-2])
Luaran:
Total lokasi berdasarkan provinsi: 35
Total data terkonfirmasi: 4257243
 Machine Learning untuk Kasus Covid-19 305

Total data sembuh: 4105680

Total data meninggal: 143858
Total kasus aktif: 7705
Total kasus selesai: 4249538
Aproksima dari kasus terkonfirmasi per hari: 6621.0
Aproksima dari kasus sembuh per hari: 6385.0
Aproksima dari kasus meninggal per hari: 224.0
Aproksima dari kasus terkonfirmasi per jam: 276.0
Aproksima dari kasus sembuh per jam: 266.0
Aproksima dari kasus meninggal per jam: 9.0
Kasus terkonfirmasi 24 jam terakhir: -4092971
Kasus sembuh 24 jam terakhir: -3945097
Kasus meninggal 24 jam terakhir: -139465
Pembahasan: Kasus dalam 24 jam terakhir bernilai negatif karena ada penurunan jumlah
kasus, baik secara keseluruhan maupun sembuh dan meninggal.
Tahap 9. Kita akan memvisualisasikan untuk kasus aktif
import plotly.express as px
import plotly.graph_objects as go
from plotly.subplots import make_subplots
fig = px.bar(x=datewise.
index, y=datewise[“Total Active Cases”])
fig.update_layout(title=”Distribusi dari kasus aktif”,
xaxis_title=”Date”, yaxis_
title=”Jumlah kasus”)
fig.show()
306 Machine Learning dengan Python

Gambar 6.8 Kasus aktif untuk Indonesia pada periode Maret-Desember 2021 pada sumbu horizontal
tanggal (ditulis Date) dan banyaknya kasus (sumbu vertikal)

Terlihat pada Gambar 6.8, bahwa kasus aktif memuncak pada sekitar Juli-Agustus 2021
yang kita ketahui bahwa pada periode ini, mobilitas penduduk lebih tinggi daripada pada
masa sebelumnya karena adanya hari raya Ramadhan yang biasanya penduduk melakukan
kunjungan, baik pada orang tua ataupun kerabat dan teman.
Tahap 10. Visualisasi untuk kasus selesai (meninggal atau sembuh)
fig = px.bar(x=datewise.index, y=datewise
[“Total Recovered”]+datewise[“Total Deaths”])
fig.update_layout(title=”Distribusi kemungkinan dari
kasus yang selesai (meninggal atau sembuh)”,
xaxis_title=”Date”, yaxis_title=”-
Jumlah Kasus”)
fig.show()

Gambar 6.9 Kasus selesai (meninggal atau sembuh) untuk Indonesia pada periode Maret-Desember
2021 pada sumbu horizontal tanggal (ditulis Date) dan banyaknya kasus (sumbu = vertikal)
 Machine Learning untuk Kasus Covid-19 307

Tahap 11. Menganalisis data mingguan

#analisis berdasarkan minggu
weekwise=datewise.index.isocalendar().week
week_num=[]
weekwise_confirmed=[]
weekwise_recovered=[]
weekwise_deaths=[]
w=1
for i in list(weekwise.unique()):
weekwise_confirmed.append(datewise[weekwise==i]
[“Total Cases”].iloc[-1])
weekwise_recovered.append(datewise[weekwise==i]
[“Total Recovered”].iloc[-1])
weekwise_deaths.append(datewise[weekwise==i]
[“Total Deaths”].iloc[-1])
week_num.append(w)
w=w+1
fig=go.Figure()
fig.add_trace(go.Scatter(x=week_num,
y=weekwise_confirmed,
mode=’lines+markers’,
name=’Pertumbuhan kasus
setiap minggu’))
fig.add_trace(go.Scatter(x=week_num,
y=weekwise_recovered,
mode=’lines+markers’,
name=’Pertumbuhan sembuh
setiap minggu’))
fig.add_trace(go.Scatter(x=week_num, y=weekwise_deaths,
mode=’lines+markers’,
308 Machine Learning dengan Python

name=’Pertumbuhan meninggal
setiap minggu’))
fig.update_layout(title=”Pertumbuhan kasus mingguan”,
xaxis_title=”Minggu”,yaxis_title
=”Jumlah Kasus”,legend=dict(x=0,y=1,traceorder
=”normal”))
fig.show()

Gambar 6.10 Kasus pertumbuhan mingguan untuk Indonesia pada periode Maret-Desember 2021
pada sumbu horizontal dan banyaknya kasus (sumbu = vertikal)

Tahap 12. Analisis pertumbuhan kasus pada jumlah kasus dan kasus kematian
fig, (ax1,ax2) = plt.subplots(2, 1, figsize=(18,10))
sns.barplot(x=week_num,y=pd.Series(weekwise_confirmed).
diff().fillna(0),ax=ax1)
sns.barplot(x=week_num,y=pd.Series(weekwise_deaths).
diff().fillna(0),ax=ax2)
ax1.set_xlabel(“minggu”)
ax2.set_xlabel(“minggu”)
ax1.set_ylabel(“Jumlah kasus”)
ax2.set_ylabel(“Jumlah kasus kematian”)
 Machine Learning untuk Kasus Covid-19 309

ax1.set_title(“Pertumbuhan mingguan pada total kasus”)

ax2.set_
title(“Pertumbuhan mingguan pada kasus kematian”)

Gambar 6.11 Kasus pertumbuhan mingguan total kasus untuk Indonesia periode Maret-Desember
2021 pada sumbu horizontal dan banyaknya kasus (sumbu = vertikal)

Gambar 6.12 Kasus pertumbuhan mingguan kasus kematian untuk Indonesia periode Maret-Desember
2021 pada sumbu horizontal dan banyaknya kasus (sumbu vertikal)
310 Machine Learning dengan Python

Tahap 13. Memvisualisasikan berbagai jenis kasus pada 1 layar

#pertumbuhan jenis kasus
fig=go.Figure()
fig.add_trace(go.Scatter(x=datewise.index,
y=datewise[“Total Cases”],
mode=’lines+markers’,
name=’Jumlah Kasus’))
fig.add_trace(go.Scatter(x=datewise.index,
y=datewise[“Total Recovered”],
mode=’lines+markers’,
name=’Sembuh’))
fig.add_trace(go.Scatter(x=datewise.index,
y=datewise[“Total Deaths”],
mode=’lines+markers’,
name=’Meninggal’))
fig.update_layout(title=”Pertumbuhan berbagai jenis
kasus”,
xaxis_title=”Tanggal”,yaxis_title
=”Jumlah kasus”,legend=dict(x=0,y=1,traceorder
=”normal”))
fig.show()
 Machine Learning untuk Kasus Covid-19 311

Gambar 6.13 Kasus pertumbuhan kasus kematian, sembuh, total kasus untuk Indonesia periode
Maret-Desember 2021 pada sumbu horizontal dan banyaknya kasus (sumbu vertikal)

print(“Rata-rata kenaikan harian dari jumlah ka-

sus:”,np.round(datewise[“Total Cases”].diff().fillna(0).
mean()))
print(“Rata-rata kenaikan harian dari kesembuhan:”,np.
round(datewise[“Total Recovered”].diff().fillna(0).
mean()))
print(“Rata-rata kenaikan harian dari kematian: “,np.
round(datewise[“Total Deaths”].diff().fillna(0).mean()))

fig=go.Figure()
fig.add_trace(go.Scatter(x=datewise.index,
y=datewise[“Total Cases”].diff().fillna(0),
mode=’lines+markers’,
name=’Jumlah kasus’))
312 Machine Learning dengan Python

fig.add_trace(go.Scatter(x=datewise.index,
y=datewise[“Total Recovered”].diff().fillna(0),
mode=’lines+markers’,
name=’Jumlah kesembuhan’))
fig.add_trace(go.Scatter(x=datewise.index,
y=datewise[“Total Deaths”].diff().fillna(0),
mode=’lines+markers’,
name=’Jumlah kematian’))
fig.update_layout(title=”Jumlah kenaikan
harian dari berbagai kasus”,
xaxis_title=”Date”,yaxis_title
=”Jumlah kasus”,legend=dict(x=0,y=1,traceorder
=”normal”))
fig.show()
Dari perintah di atas diperoleh hasil bahwa:
Rata-rata kenaikan harian dari jumlah kasus: 6621.0
Rata-rata kenaikan harian dari kesembuhan: 6385.0
Rata-rata kenaikan harian dari kematian: 224.0

Gambar 6.14 Kasus pertumbuhan harian kasus kematian, sembuh, total kasus untuk Indonesia periode
Maret-Desember 2021 pada sumbu horizontal dan banyaknya kasus (sumbu vertikal)
 Machine Learning untuk Kasus Covid-19 313

Grafik pada Gambar 6.14 menunjukkan rata-rata kasus tertinggi ada di sekitar bulan Juli 2021
dan rata-rata penurunan kasus yang sangat banyak sebelum bulan Januari 2022.
Tahap 14. Kita melakukan analisis berdasarkan provinsi
Analisis berdasarkan provinsi
countrywise=gruping_location.groupby([“Location”]).
agg({“Total Cases”:’sum’,”Total Recovered”:’sum’,
”Total Deaths”:’sum’, “Total Active Cases”:’sum’}).
sort_values([“Total Cases”],ascending=False)
countrywise[“kematian”]=(countrywise[“Total Deaths”]/
countrywise[“Total Cases”])*100
countrywise[“sembuh”]=(countrywise[“Total Recovered”]/
countrywise[“Total Cases”])*100

countrywise
314 Machine Learning dengan Python

Tahap 15. Kita akan gambarkan 10 provinsi terbanyak untuk total kasus, total sembuh,
dan total meninggal
fig, (ax1, ax2, ax3) = plt.subplots
(3, 1,figsize=(10,20))
top_10kasus=countrywise.sort_values
([“Total Cases”],ascending=False).head(10)
top_10sembuh=countrywise.sort_values
([“Total Recovered”], ascending=False).head(10)
top_10kematian=countrywise.sort_values
([“Total Deaths”],ascending=False).head(10)
sns.barplot(x=top_10kasus[“Total Cases”],
y=top_10kasus.index,ax=ax1)
ax1.set_title(“Top 10 provinsi dari jumlah kasus”)
sns.barplot(x=top_10sembuh
[“Total Recovered”],y=top_10sembuh.index,ax=ax2)
ax2.set_title(“Top 10 provinsi dari jumlah
kesembuhan”)
 Machine Learning untuk Kasus Covid-19 315

sns.barplot(x=top_10kematian[“To-
tal Deaths”],y=top_10kematian.index,ax=ax3)
ax3.set_title(“Top 10 provinsi dari jumlah kematian”)

Gambar 6.15 Lokasi 10 terbanyak untuk total kasus Covid-19 di Indonesia periode Maret 2021-Oktober
2021

Gambar 6.16 Lokasi 10 terbanyak untuk total kasus sembuh Covid-19 di Indonesia periode Maret
2021-Oktober 2021
316 Machine Learning dengan Python

Gambar 6.17 Lokasi 10 terbanyak untuk total kasus kematian Covid-19 di Indonesia periode Maret
2021-Oktober 2021

Dengan memperhatikan Gambar 6.15-6.17, tampak bahwa kota dengan populasi terpadat di
Indonesia dengan kasus Covid-19 terbanyak, serta dengan pasien sembuh paling banyak,
akan tetapi kematian justru terjadi paling tinggi di Jawa Timur.
Tahap 16. Kita mempelajari pada kasus dalam 24 jam terakhir dari data yang diperoleh
provinsi_terkonfirmasi_24jamterakhir = []
provinsi_sembuh_24jamterakhir=[]
provinsi_kematian_24jamterakhir=[]
for provinsi in countrywise.index:
provinsi_terkonfirmasi_24jamterakhir.append((np.
abs(gruping_location.loc[provinsi].iloc[-1]-gruping_
location.loc[provinsi].iloc[-2]))[“Total Cases”])
provinsi_sembuh_24jamterakhir.append((np.abs(grup-
ing_location.loc[provinsi].iloc[-1]-gruping_location.
loc[provinsi].iloc[-2]))[“Total Recovered”])
provinsi_kematian_24jamterakhir.append((np.abs(-
gruping_location.loc[provinsi].iloc[-1]-gruping_loca-
tion.loc[provinsi].iloc[-2]))[“Total Deaths”])
 Machine Learning untuk Kasus Covid-19 317

provinsi_24jamterakhir = pd.DataFrame(list(zip(coun-
trywise.index,provinsi_terkonfirmasi_24jamterakh-
ir,provinsi_sembuh_24jamterakhir,provinsi_kematian_
24jamterakhir)),
columns=[“Provinsi”,
”Kasus 24 jam terakhir”,”Sembuh 24 jam terakhir”,”Ke-
matian 24 jam terakhir”])
Top_10kasus_prov=provinsi_24jamterakhir.sort_val-
ues([“Kasus 24 jam terakhir”],ascending=False).
head(10)
Top_10sembuh_prov=provinsi_24jamterakhir.sort_val-
ues([“Sembuh 24 jam terakhir”],ascending=False).
head(10)
Top_10kematian_prov=provinsi_24jamterakhir.sort_val-
ues([“Kematian 24 jam terakhir”],ascending=False).
head(10)

fig, (ax1, ax2, ax3) = plt.subplots(3, 1,fig-

size=(10,20))
sns.barplot(x=Top_10kasus_prov[“Kasus 24 jam terakh-
ir”],y=Top_10kasus_prov[“Provinsi”],ax=ax1)
ax1.set_title(“Top 10 provinsi selama 24 jam terakh-
ir”)
sns.barplot(x=Top_10sembuh_prov[“Sembuh 24 jam terakh-
ir”],y=Top_10sembuh_prov[“Provinsi”],ax=ax2)
ax2.set_title(“Top 10 provinsi dalam kasus sembuh se-
lama 24 jam terakhir”)
sns.barplot(x=Top_10kematian_prov[“Kema-
tian 24 jam terakhir”],y=Top_10kematian_prov[“Provin-
si”],ax=ax3)
ax3.set_title(“Top 10 provinsi dalam kasus kema-
tian selama 24 jam terakhir”)
318 Machine Learning dengan Python

Gambar 6.18 Lokasi 10 terbanyak untuk total kasus Covid-19 pada 24 jam terakhir di Indonesia periode
Maret 2021-Oktober 2021

Gambar 6.19 Lokasi 10 terbanyak untuk total kasus sembuh Covid-19 pada 24 jam terakhir di
Indonesia periode Maret 2021-Oktober 2021
 Machine Learning untuk Kasus Covid-19 319

Gambar 6.20 Lokasi 10 terbanyak untuk total kasus kematian Covid-19 pada 24 jam terakhir di
Indonesia periode Maret 2021-Oktober 2021

Tahap 17. Proporsi kasus dalam 24 jam terakhir pada tiap provinsi
provinsi_24jamterakhir[“Proporsi dari kasus”]=np.
abs((provinsi_24jamterakhir[“Kasus 24 jam terakhir”]/
(datewise[“Total Cases”].iloc[-1]-datewise
[“Total Cases”].iloc[-2]))*100)
provinsi_24jamterakhir[“Proporsi dari sembuh”]=np.
abs((provinsi_24jamterakhir[“Sembuh 24 jam terakhir”]/
(datewise[“Total Recovered”].iloc[-1]-datewise
[“Total Recovered”].iloc[-2]))*100)
provinsi_24jamterakhir[“Proporsi dari kematian”]=np.
abs((provinsi_24jamterakhir[“Kematian 24 jam
terakhir”]/(datewise[“Total Deaths”].
iloc[-1]-datewise[“Total Deaths”].iloc[-2]))*100)

provinsi_24jamterakhir[[“Provinsi”,”Proporsi dari
kasus”,”Proporsi dari sembuh”,”Proporsi dari
kematian”]].sort_values([“Proporsi dari kasus”],
ascending=False).style.background_gradient(c-
map=”Reds”)
320 Machine Learning dengan Python
 Machine Learning untuk Kasus Covid-19 321

Tahap 18. Kasus untuk 10 provinsi terbanyak dengan kasus selesai

fig, (ax1, ax2) = plt.subplots(2, 1,figsize=(10,15))
countrywise[“Kasus selesai”]=(countrywise[“Total
Recovered”]+countrywise[“Total Deaths”])
top_10aktif=countrywise.sort_values([“Total
Active Cases”],ascending=False).head(10)
top_10selesai=countrywise.sort_values([“Kasus
selesai”],ascending=False).head(10)
sns.barplot(x=top_10aktif[“Total Active
Cases”],y=top_10aktif.index,ax=ax1)
sns.barplot(x=top_10selesai[“Kasus
selesai”],y=top_10selesai.index,ax=ax2)
ax1.set_title(“Top 10 provinsi kasus terbanyak”)
ax2.set_title(“Top 10 provinsi kasus selesai”)
322 Machine Learning dengan Python

Gambar 6.21 Lokasi 10 provinsi terbanyak untuk total kasus aktif Covid-19 di Indonesia periode Maret
2021-Oktober 2021

Gambar 6.22 Lokasi 10 provinsi terbanyak untuk total kasus selesai (mati/sembuh) Covid-19
di Indonesia periode Maret 2021-Oktober 2021
 Machine Learning untuk Kasus Covid-19 323

Pada bagian selanjutnya, kita akan melakukan klasterisasi dengan Machine Learning
setelah membaca data.

6.3. Klasterisasi Data Covid-19 di Indonesia

Tahap 1. Memanggil librari yang diperlukan
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score,
silhouette_samples
#from sklearn.linear_model import
LinearRegression,Ridge,Lasso
#from sklearn.svm import SVR
#from sklearn.metrics import mean_squared_error,r2_
score
#import statsmodels.api as sm
#from statsmodels.tsa.api import Holt,
SimpleExpSmoothing,ExponentialSmoothing
#from fbprophet import Prophet
#from sklearn.preprocessing import PolynomialFeatures
Tahap 2. Dilakukan standardisasi data
Misalkan klasterisasi dilakukan terhadap data kematian dan sembuh
X=countrywise[[“kematian”,’sembuh’]]
std=StandardScaler()
X= std.fit_transform(X)
Tahap 3. Menggunakan k-means clustering
wcss=[]
sil=[]
for i in range(2,11):
clf=KMeans(n_clusters=i,init=’k-means++’,random_
324 Machine Learning dengan Python

state=128)
clf.fit(X)
labels=clf.labels_
centroids=clf.cluster_centers_
sil.append(silhouette_
score(X, labels, metric=’euclidean’))
wcss.append(clf.inertia_)
x=np.arange(2,11)
plt.figure(figsize=(10,5))
plt.plot(x,wcss,marker=’o’)
plt.xlabel(“Klaster”)
plt.ylabel(“Within Cluster Sum of Squares (WCSS)”)
plt.title(“Model Elbow”)

Gambar 6.23 Hasil model Elbow pada klasterisasi K-means data kematian dan sembuh kasus Covid-19
di Indonesia periode Maret 2021-Oktober 2021
 Machine Learning untuk Kasus Covid-19 325

Tahap 4. Membuat dendrogram dari klaster hierarki

import scipy.cluster.hierarchy as sch
plt.figure(figsize=(15,5))
dendogram=sch.dendrogram(sch.
linkage(X, method = “ward”))

Gambar 6.24 Hasil klasterisasi hierarki data kematian dan sembuh kasus Covid-19 di Indonesia
periode Maret 2021-Oktober 2021

Tahap 5.
clf_final=KMeans(n_clusters=3,init=’k-means++’,random_
state=6)
clf_final.fit(X)
klaster=clf_final.predict(X)
Tahap 6.
plt.figure(figsize=(10,5))
sns.scatterplot(x=countrywise[“sembuh”],
y=countrywise[“kematian”],hue=klaster,s=100)
plt.axvline(((datewise[“Total Recovered”]/datewise
[“Total Cases”])*100).mean(),
color=’red’,linestyle=”--”,label=”Rata-
rata tingkat sembuh”)
plt.axhline(((datewise[“Total Deaths”]/datewise
326 Machine Learning dengan Python

[“Total Cases”])*100).mean(),
color=’black’,linestyle=”--”,label=”Ra-
ta-rata tingkat kematian”)
plt.legend()

Gambar 6.25 Klasifikasi data kasus Covid-19 antara kematian dan sembuh dalam kelompok provinsi
dalam 3 kluster dengan memperhatikan rata-rata tingkat sembuh dan rata-rata tiap kematian

print(“Provinsi klaster 0: “,
list(countrywise[klaster==0].head(10).index))
print(“Provinsi klaster 1: “,
list(countrywise[klaster==1].head(10).index))
print(“Provinsi klaster 2: “,
list(countrywise[klaster==2].head(10).index))
Luaran:
Provinsi klaster 0: [‘DKI Jakarta’, ‘Jawa Barat’,
‘Kalimantan Timur’, ‘Sulawesi Selatan’, ‘Daerah
Istimewa Yogyakarta’, ‘Riau’, ‘Banten’, ‘Bali’,
‘Sumatera Barat’, ‘Sumatera Utara’]
Provinsi klaster 1: [‘Jawa Tengah’, ‘Jawa Timur’,
‘Sumatera Selatan’, ‘Lampung’, ‘Aceh’]
Provinsi klaster 2: [‘Papua’]
 Machine Learning untuk Kasus Covid-19 327

Pembahasan: pada klaster 0 ditunjukkan bahwa DKI Jakarta, Jawa Barat, dan lainnya (lihat
luaran) merupakan kelompok provinsi dengan angka kesembuhan tertinggi dan kematian
terendah di mana tingkat kematian dibedakan menjadi 2 kelompok (di bawah 5.5 dan di
atasnya), sedangkan provinsi Papua dengan kematian dan kesembuhan paling rendah yang
mengindikasikan rendahnya kasus Covid-19 di Papua dibandingkan provinsi yang lainnya.

6.4. Data Covid-19 Dunia

Untuk selanjutnya, kita akan mencoba menggunakan Machine Learning untuk melakukan
visualisasi dan sedikit analisis dengan data dari kasus Covid-19 dunia. Tahapan juga serupa
sebagaimana data sebelumnya. Adapun kode yang digunakan diambil secara umum: https://
www.kaggle.com/therealcyberlord/coronavirus-covid-19-visualization-prediction.
Tahap 1. Memanggil librari yang digunakan
#https://www.kaggle.com/therealcyberlord/coronavirus-
covid-19-visualization-prediction
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.colors as mcolors
import pandas as pd
import random
import math
import time
from sklearn.linear_
model import LinearRegression, BayesianRidge
from sklearn.model_
selection import RandomizedSearchCV, train_test_split
from sklearn.preprocessing import PolynomialFeatures
from sklearn.svm import SVR
from sklearn.metrics import mean_squared_error, mean_
absolute_error
import datetime
import operator
328 Machine Learning dengan Python

Tahap 2. Kita membaca data dari github dengan alamat yang dituju. Hal ini melatih kita
bagaimana membaca data yang diberikan oleh alamat lain asalkan alamat link jelas
confirmed_df = pd.read_csv(‘https://raw.
githubusercontent.com/CSSEGISandData/COVID-19/master/
csse_covid_19_data/csse_covid_19_time_series/time_
series_covid19_confirmed_global.csv’)
deaths_df = pd.read_csv(‘https://raw.
githubusercontent.com/CSSEGISandData/COVID-19/master/
csse_covid_19_data/csse_covid_19_time_series/time_
series_covid19_deaths_global.csv’)
Tahap 3. Memanggil data dan fitur-fiturnya
confirmed_df.head()
cols = confirmed_df.keys()

Pembahasan: Kita dapat melihat tampilan dari perintah tersebut.

cols (ENTER)
Index([‘Province/State’, ‘Country/Region’, ‘Lat’,
‘Long’, ‘1/22/20’, ‘1/23/20’,
‘1/24/20’, ‘1/25/20’, ‘1/26/20’, ‘1/27/20’,
...
‘5/18/22’, ‘5/19/22’, ‘5/20/22’, ‘5/21/22’,
‘5/22/22’, ‘5/23/22’,
‘5/24/22’, ‘5/25/22’, ‘5/26/22’, ‘5/27/22’],
dtype=’object’, length=861)
Pembahasan: Tampak bahwa data sampai dengan mulai 22 Januari 2020 hingga 27 Mei
2022. Jika Anda menuju pada file sesuai alamat, Anda akan menjumpai daftar isian dalam Big
Data. Sebagian data tentang tampilan tanggal untuk data yang terkonfirmasi ditunjukkan pada
Gambar 6.22, sedangkan data yang terkonfirmasi dengan tampilan yang ditunjukkan pada
Gambar 6.23.
 Machine Learning untuk Kasus Covid-19 329

Tahap 4. Mencermati beberapa data

confirmed = confirmed_df.loc[:, cols[4]:cols[-1]]
deaths = deaths_df.loc[:, cols[4]:cols[-1]]
Hasil perintah tersebut untuk confirmed
1/22/20 1/23/20 1/24/20 1/25/20 1/26/20 1/27/20
1/28/20 1/29/20 \
0 0 0 0 0 0
0 0 0
1 0 0 0 0 0
0 0 0
2 0 0 0 0 0
0 0 0
3 0 0 0 0 0
0 0 0
4 0 0 0 0 0
0 0 0
.. ... ... ... ... ...
... ... ...
280 0 0 0 0 0
0 0 0
281 0 0 0 0 0
0 0 0
282 0 0 0 0 0
0 0 0
283 0 0 0 0 0
0 0 0
284 0 0 0 0 0
0 0 0

1/30/20 1/31/20 ... 5/18/22 5/19/22 5/20/22

5/21/22 5/22/22 \
330 Machine Learning dengan Python

0 0 0 ... 179477 179597 179624

179674 179716
1 0 0 ... 275732 275732 275732
275838 275864
2 0 0 ... 265834 265841 265847
265851 265854
3 0 0 ... 42572 42572 42572
42572 42572
4 0 0 ... 99287 99287 99287
99287 99287
.. ... ... ... ... ... ...
... ...
280 0 0 ... 657456 657456 657456
657456 657456
281 0 0 ... 535 535 535
535 535
282 0 0 ... 11819 11819 11819
11819 11819
283 0 0 ... 320680 320945 320945
321099 321146
284 0 0 ... 250007 250206 250469
250469 250642

5/23/22 5/24/22 5/25/22 5/26/22 5/27/22

0 179716 179771 179835 179835 180086
1 275881 275939 275985 276012 276048
2 265855 265860 265862 265864 265870
3 42572 42572 42894 42894 42894
4 99287 99433 99527 99527 99527
.. ... ... ... ... ...
 Machine Learning untuk Kasus Covid-19 331

280 657573 657573 657573 657573 657573

281 535 535 535 535 535
282 11819 11819 11819 11819 11819
283 321195 321268 321342 321399 321503
284 250702 250929 251228 251646 251959

[285 rows x 857 columns]

Pembahasan: Data memuat 285 baris dengan 857 kolom yang diambil dari tanggal mulainya
dilakukan perhitungan. Perhatikan bahwa kolom-kolom sebelumnya adalah fitur-fitur
‘Province/State’, ‘Country/Region’, ‘Lat’, ‘Long’. Jadi, 285 baris menyatakan sebanyak negara
yang tercatat di mana masing-masing negara ditulis provinsinya (kolom ke-1) dan posisinya
berdasarkan lintang dan bujurnya dengan nama fitur ‘Lat’, ‘Long’.
Tahap 5.
Selanjutnya kita akan mencermati untuk kasus dunia dan pada 2 negara lain sebagai contoh
pembahasan untuk data yang terkonfirmasi dan yang mati. Mengapa yang tidak ter-recovered?
Karena mungkin pada sumber data pencatatannya tidak sebagaimana 2 fitur lain yang
terdokumentasi secara teratur tiap tanggal sehingga pada yang recovered tidak dapat diakses.
332 Machine Learning dengan Python

Gambar 6.26 Daftar tanggal pada data yang diolah

(Sumber: https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/
csse_covid_19_time_series/time_series_covid19_confirmed_global.csv, pada tanggal 28 Mei 2022)

Gambar 6.27 Contoh tampilan yang terkonfirmasi dari 5 baris pertama (‘confirmed’) data yang diolah

(Sumber: https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/
csse_covid_19_time_series/time_series_covid19_confirmed_global.csv, pada tanggal 28 Mei 2022)

Catatan: Jika program dijalankan pada waktu yang berbeda maka terjadi perubahan data,
misalkan buku ini ditulis dengan melakukan running program pada 16 Juli 2022. Data terjadi
perubahan di mana data terakhir yang tercatat adalah pada tanggal 15 Juli 2022. Hal ini
ditunjukkan pada Gambar 6.28.
 Machine Learning untuk Kasus Covid-19 333

1/22/20 1/23/20 1/24/20 1/25/20 1/26/20 1/27/20

1/28/20 1/29/20 \
0 0 0 0 0 0
0 0 0
1 0 0 0 0 0
0 0 0
2 0 0 0 0 0
0 0 0
3 0 0 0 0 0
0 0 0
4 0 0 0 0 0
0 0 0
.. … … … … … … …
…
280 0 0 0 0 0
0 0 0
281 0 0 0 0 0
0 0 0
282 0 0 0 0 0
0 0 0
283 0 0 0 0 0
0 0 0
284 0 0 0 0 0
0 0 0

1/30/20 1/31/20 … 7/6/22 7/7/22 7/8/22

7/9/22 7/10/22 7/11/22 \
0 0 0 … 182979 183084 183221
183235 183265 183268
1 0 0 … 283811 284758 285731
286732 287984 288176
2 0 0 … 266181 266202 266228
266246 266257 266274
334 Machine Learning dengan Python

3 0 0 … 44671 44671 44671

44671 44671 44671
4 0 0 … 101320 101320 101320
101320 101320 101320
.. … … … … … … … …
…
280 0 0 … 662490 662490 662490
662490 662490 662490
281 0 0 … 535 535 535
535 535 535
282 0 0 … 11832 11832 11832
11832 11832 11832
283 0 0 … 326408 326651 326794
326794 327052 327102
284 0 0 … 255805 255805 255891
255924 255939 255953

7/12/22 7/13/22 7/14/22 7/15/22

0 183272 183285 183358 183407
1 289391 290954 290954 293917
2 266303 266328 266356 266392
3 44671 44671 44671 44671
4 101320 101320 101600 101901
.. … … … …
280 662588 662588 662588 662588
281 535 535 535 535
282 11832 11832 11832 11832
283 327102 327102 327102 327994
284 255981 255981 256047 256083

[285 rows x 906 columns]

Gambar 6.28 Hasil pendataan yang didaftar dengan melakukan running program pada tanggal 16 Juli
2022 maka tercatat data hingga 15 Juli 2022
 Machine Learning untuk Kasus Covid-19 335

Program Python sebagai berikut:

dates = confirmed.keys()
world_cases = []
total_deaths = []
mortality_rate = []
# recovery_rate = []
# total_recovered = []
total_active = []
china_cases = []
italy_cases = []
us_cases = []
for i in dates:
confirmed_sum = confirmed[i].sum()
death_sum = deaths[i].sum()

# confirmed, deaths, recovered

world_cases.append(confirmed_sum)
total_deaths.append(death_sum)

# Hitung lajunya
mortality_rate.append(death_sum/confirmed_sum)
# recovery_rate.append(recovered_sum/confirmed_sum)
#Kasus yang dipelajari
china_cases.append(confirmed_df[confirmed_
df[‘Country/Region’]==’China’][i].sum())
italy_cases.append(confirmed_df[confirmed_
df[‘Country/Region’]==’Italy’][i].sum())
us_cases.append(confirmed_df[confirmed_df[‘Country/
Region’]==’US’][i].sum())
336 Machine Learning dengan Python

Kemudian mencatatkan berdasarkan penambahan data:

def daily_increase(data):
d = []
for i in range(len(data)):
if i == 0:
d.append(data[0])
else:
d.append(data[i]-data[i-1])
return d

world_daily_increase = daily_increase(world_cases)
china_daily_increase = daily_increase(china_cases)
italy_daily_increase = daily_increase(italy_cases)
us_daily_increase = daily_increase(us_cases)
days_since_1_length = np.
array([i for i in range(len(dates))]).reshape(-1, 1)
world_cases = np.array(world_cases).reshape(-1, 1)
total_deaths = np.array(total_deaths).reshape(-1, 1)

days_in_future = 10
future_forcast = np.
array([i for i in range(len(dates)+days_in_future)]).
reshape(-1, 1)
adjusted_dates = future_forcast[:-10]
Tahap 1. Mulai dengan Machine Learning dengan melakukan pemisahan data
X_train_confirmed, X_test_confirmed, y_train_
confirmed, y_test_confirmed = train_test_
split(days_since_1_length, world_cases, test_
size=0.15, shuffle=False)
 Machine Learning untuk Kasus Covid-19 337

Tahap 2. Kita menggunakan SVR dalam melakukan analisis data

svm_confirmed = SVR(shrinking=True, kernel=’poly’,
gamma=0.1, epsilon=1,degree=4, C=0.1)
svm_confirmed.fit(X_train_confirmed, y_train_confirmed)
svm_pred = svm_confirmed.predict(future_forcast)

# dicek kembali
svm_test_pred = svm_confirmed.predict(X_test_confirmed)
plt.plot(svm_test_pred)
plt.plot(y_test_confirmed)
print(‘MAE:’, mean_absolute_error(svm_test_pred, y_
test_confirmed))
print(‘MSE:’,mean_squared_error(svm_test_pred, y_test_
confirmed))
Tahap 3. Mentransformasi data ke transformasi regresi
# transform our data for polynomial regression
poly = PolynomialFeatures(degree=5)
poly_X_train_confirmed = poly.fit_transform(X_train_
confirmed)
poly_X_test_confirmed = poly.fit_transform(X_test_
confirmed)
poly_future_forcast = poly.fit_transform(future_
forcast)
Tahap 4. Melakukan regresi polinomial
polynomial regression
linear_mo del = LinearRegression(normalize=True, fit_
intercept=False)
linear_model.fit(poly_X_train_confirmed, y_train_
confirmed)
test_linear_pred = linear_model.predict(poly_X_test_
confirmed)
338 Machine Learning dengan Python

linear_pred = linear_model.predict(poly_future_
forcast)
print(‘MAE:’, mean_absolute_error(test_linear_pred, y_
test_confirmed))
print(‘MSE:’,mean_squared_error(test_linear_pred, y_
test_confirmed))
Luaran:
MAE: 12863.692361032718
MSE: 284678459.52575696
Tahap 5a
print(linear_model.coef_)
Luaran:
[[ 2.68814745e+03 -1.78526205e+03 3.66976536e+02
-7.95865916e+00
-3.17544829e-02 1.58894877e-03]]
KodeTeks
Tahap 5b
plt.plot(test_linear_pred)
plt.plot(y_test_confirmed)
Luaran:

Gambar 6.29 Visualisasi prediksi linear dan data uji dengan kasus yang terkonfirmasi data kasus
Covid-19 dunia sejak Januari 2020 hingga Maret 2020
 Machine Learning untuk Kasus Covid-19 339

Tahap 6. Melakukan Bayesian regresi

tol = [1e-4, 1e-3, 1e-2]
alpha_1 = [1e-7, 1e-6, 1e-5, 1e-4]
alpha_2 = [1e-7, 1e-6, 1e-5, 1e-4]
lambda_1 = [1e-7, 1e-6, 1e-5, 1e-4]
lambda_2 = [1e-7, 1e-6, 1e-5, 1e-4]

bayesian_grid = {‘tol’: tol, ‘alpha_1’: alpha_1, ‘al-

pha_2’ : alpha_2, ‘lambda_1’: lambda_1, ‘lamb-
da_2’ : lambda_2}

bayesian = BayesianRidge(fit_intercept=False, normal-

ize=True)
bayesian_search = RandomizedSearchCV(bayesian, bayes-
ian_grid, scoring=’neg_mean_squared_error’, cv=3, re-
turn_train_score=True, n_jobs=-1, n_iter=40, ver-
bose=1)
bayesian_search.fit(poly_X_train_confirmed, y_train_con-
firmed)
Luaran:
Fitting 3 folds for each of 40 candidates, totalling
120 fits
[Parallel(n_jobs=-1)]: Using backend LokyBackend with
4 concurrent workers.
[Parallel(n_jobs=-1)]: Done 47 tasks | elapsed:
20.5s
[Parallel(n_jobs=-1)]: Done 120 out of 120 | elapsed:
21.6s finished
C:\ProgramData\Anaconda3\lib\site-packages\sklearn\
utils\validation.py:724: DataConversionWarning: A col-
umn-vector y was passed when a 1d array was expected.
Please change the shape of y to (n_samples, ), for ex-
340 Machine Learning dengan Python

ample using ravel().

y = column_or_1d(y, warn=True)
RandomizedSearchCV(cv=3, error_score=’raise-deprecat-
ing’,
estimator=BayesianRidge(al-
pha_1=1e-06, alpha_2=1e-06,
compute_score=False, copy_X=True,
fit_intercept=False, lambda_1=1e-06,
lambda_2=1e-06,
n_iter=300,
normalize=True,
tol=0.001,
verbose=False),
iid=’warn’, n_iter=40, n_jobs=-1,
param_distributions={‘alpha_1’:
[1e-07, 1e-06, 1e-05,

0.0001],
‘alpha_2’: [1e-
07, 1e-06, 1e-05,

0.0001],
‘lambda_1’: [1e-07,
1e-06, 1e-05,

0.0001],
‘lambda_2’: [1e-07,
1e-06, 1e-05,

0.0001],
‘tol’: [0.0001, 0.001,
0.01]},
 Machine Learning untuk Kasus Covid-19 341

pre_dispatch=’2*n_jobs’, random_state=None,
refit=True,
return_train_score=True,
scoring=’neg_mean_squared_error’,
verbose=1)
Tahap 7.
bayesian_search.best_params_
Luaran:
{‘tol’: 0.0001, ‘lambda_2’: 0.0001, ‘lambda_1’: 1e-06,
‘alpha_2’: 1e-07, ‘alpha_1’: 0.0001}
Tahap 8. Model Bayesian untuk yang terkonfirmasi
bayesian_confirmed = bayesian_search.best_estimator_
test_bayesian_pred = bayesian_confirmed.predict(poly_X_
test_confirmed)
bayesian_pred = bayesian_confirmed.predict(poly_future_
forcast)
print(‘MAE:’, mean_absolute_error(test_bayesian_
pred, y_test_confirmed))
print(‘MSE:’,mean_squared_error(test_bayesian_pred, y_
test_confirmed))
Luaran:
MAE: 7674.882332597836
MSE: 63836099.3390154
Tahap 9. Menggambar visualisasi data uji yang terkonfirmasi positif Covid-19 dengan yang
data uji hasil prediksi
plt.plot(y_test_confirmed)
plt.plot(test_bayesian_pred)
342 Machine Learning dengan Python

Luaran:

Gambar 6.30 Visualisasi prediksi model Bayesian terhadap data uji dengan kasus yang terkonfirmasi
data kasus Covid-19 dunia

Dari visualisasi tersebut, kita dapat melihat bahwa Bayesian regresi lebih baik daripada regresi
polinomial yang ditunjukkan pada Gambar 6.29. Kita menggunakan Bayesian ini untuk data
kasus terkonfirmasi positif pada data kasus Covid-19 di dunia periode Januari-Maret 2020. Kita
dapat menggunakan program yang sama untuk melakukan penelitian lebih lanjut.

6.5. Penutup
Berbagai pendekatan untuk pembahasan kasus Covid-19 telah dilakukan pula oleh berbagai
peneliti (Kubota et al., 2020)coronavirus disease 2019 (COVID-19, baik untuk dunia maupun
data Indonesia. Demikian pula pemodelan data kasus Covid-19 dengan menggunakan gerak
Brown (Fabiano, 2021) dan citra CT dengan Deep Learning (Swastika & Korespondensi, 2020),
juga untuk perbandingan beberapa metode dalam Machine Learning semua pendekatan.
 Machine Learning untuk Kasus Covid-19 343

DAFTAR PUSTAKA
Fabiano, N. 2021. Geometric Brownian Motion and a New Approach to the Spread of Covid-19
in Italy, 2. 10(2), 25–30.
Kubota, Y., Shiono, T., Kusumoto, B., & Fujinuma, J. 2020. Multiple Drivers of the Covid-19
Spread: The Roles of Climate, International Mobility, and Region-Specific Conditions.
PLoS ONE, 15(9 September), 1–15. https://doi.org/10.1371/journal.pone.0239385.
Parhusip, H. A. 2020. Study on Covid-19 in the World and Indonesia Using Regression Model
of SVM, Bayesian Ridge, and Gaussian. Jurnal Ilmiah Sains, 20(2), 49. https://doi.
org/10.35799/jis.20.2.2020.28256.
Swastika, W., & Korespondensi, P. 2020. Studi Awal Deteksi Covid-19 Menggunakan Citra
Ct Berbasis Deep Learning Preliminary, Study of Covid-19 Detection Using Ct Image
Based on Deep Learning. Jurnal Teknologi Informasi Dan Ilmu Komputer (JTIIK), 7(3),
629–634. https://doi.org/10.25126/jtiik.202073399.
344 Machine Learning dengan Python

INDEKS

Artificial Intelligence, 5, 60 Reinforcement Learning, 10

Cross-Validation, 8 Scikit Learn, 16, 33
data mining, 1 supervised learning, 5
Decision Tree, 9 Supervised Learning, 6, 8, 9
Decision Trees, 8, 9 Support Vector Machines, 7, 8
from sklearn.model_selection import train_ test data, 6
test_split, 15, 32, 56, 58 Train /Test Split, 16, 35
K- cross validation, 16 train/test method, 15, 32
K-Fold Cross Validation, 15, 32 training data, 4, 6
K-Nearest Neighbors, 8, 15, 17, 31, 38, 39 underfitting, 7, 17, 18, 20, 38, 60
Least-Squares, 8 unsupervised learning, 5
Linear Classifiers, 8 Unsupervised Learning, 9
Linear Regression, 8 clustering, 3, 4, 6, 7, 8, 10, 73, 74, 82, 87, 89
Logistic Regression, 8, 15, 17, 31, 35, 38 computer vision, 3
Logistik Regression, 37 DataFrame, 11, 74, 78, 80, 81, 82, 83, 84
machine learning, 1, 3, 13, 15, 18, 31 Euclid, 9, 73, 79, 84
Machine learning, 3, 5, 10, 11, 40, 60 Expectation-Maximization, 2
Machine Learning, 1, 4, 11, 12, 13, 59, 60 klaster, 1, 2, 3, 4, 5, 6, 7, 9, 10, 73, 78, 79, 81,
Markov Decision Process. 10 83, 84, 85, 86, 87, 88
Mesin Pembelajaran Terbimbing 12 K-means, 3, 82, 84, 85, 86, 87, 88
Multi-Class Classification 8 K-Means, 1, 2, 3, 5, 7, 9, 10, 73, 74, 85, 87, 88
Naïve Bayes 9 K-Means Clustering, 1, 5, 7, 10, 74
Nearest Neighbour 9 Matplotlib, 4
outlier 13, 26, 27 matplotlib.pyplot, 5, 11, 74, 79, 80, 81, 87
overfitting, 7, 14, 15, 17, 18, 19, 20, 32, 38, 60 metode Elbow, 4
polynomial regression, 7 Metode Elbow, 4
Reinforcement learning, 10 metode klaster, 1
 Indeks 345

np.random.randint, 9, 11, 73, 74 html, 99, 135, 139, 141

numpy, 4, 5, 8, 10, 74, 78, 79, 83 HTML, 101, 134, 135, 142
Numpy, 4 kata, 91, 92, 93, 94, 96, 99, 100, 101, 112,
Pandas, 4 113, 114, 117, 123, 132, 133, 134, 139, 141,
144, 145, 146, 147, 148, 151, 152, 153, 157,
pusat klaster, 1, 2, 3, 6, 79, 81, 87
160
scatter, 5, 6, 8, 9, 10, 11, 73, 74, 75, 76, 77,
Klasifikasi, 91, 93, 97, 98, 99, 102, 103, 146
80, 81, 83, 87, 88
Lemmatisasi, 91
scikitlearn, 78, 88
Lemmatization, 91
Scikit-learn, 4
list_token, 143, 144, 145, 146, 147, 148, 152
Seaborn, 4
lowering, 112, 134, 139, 141
Within Cluster Sum of Squares, 4
Luaran, 95, 96, 97, 98, 99, 105, 106, 107, 110,
“Term Frequency — Inverse Document”
111, 112, 113, 114, 132, 133, 134, 135, 138,
Frequency, 92
139, 141, 142, 144, 145, 146, 148, 149, 150,
Amazon Review Data set, 93
151, 152, 153, 154, 155, 156, 157, 158, 159,
bayes, 93, 97, 98, 99, 151, 152, 153, 155, 160, 161, 162, 163
157, 163
matplotlib, 111
Classifier Naive Bayes, 157
menggambar, 111, 146
cleaning, 112, 113, 134, 139, 141
menghapus, 94, 108, 109
Colab, 93, 94
NLP, 91
corpus, 93, 94, 96, 101, 113, 163
NLTK, 113
CountVectorizer , 157, 158
nonspam, 99, 100, 102, 111, 144, 145, 147,
data, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 148, 149, 150, 151, 152, 153, 154, 155, 156,
102, 103, 107, 108, 113, 139, 141, 143, 148, 163
155, 157, 158, 159, 162
pandas, 93, 103, 142
data training, 96, 97
Punktuasi, 133
data uji, 92, 96
Python, 93, 101, 143
DataFrame, 99, 103, 148, 151, 154, 155, 160,
sklearn, 93, 94, 98, 99, 157, 158, 162
162
spam, 91, 99, 102, 111, 144, 145, 146, 148,
Encoding, 92
149, 150, 151, 153, 154, 155, 156, 163
fungsi, 96, 100, 102, 141, 152, 153, 155, 160
stemming, 91, 99, 112, 113, 134, 139, 141
346 Machine Learning dengan Python

Stemming, 91 machine learning, 26

stopwords, 93, 95, 96, 99, 100, 113, 114, 117, margin, 1, 3, 4, 11, 12, 17, 18, 19, 21, 26, 29,
132, 133, 141 30
Test_X_Tfidf., 93 norm, 4, 22, 27
text, 91, 92, 93, 94, 95, 96, 100, 101, 135, notasi, 8, 13, 14, 27
138, 139, 141, 157 ortogonal, 6, 7
TF-IDF, 92, 93, 96 outlier, 27, 28, 29
token, 91, 92, 99, 100, 101, 143, 148, 150, Prinsip dualitas, 22
151, 152, 157, 158, 159, 160
Prinsip duality, 22
Tokenisasi, 91, 100
Python, 24, 26, 27
Tokenization, 91, 94
skalar, 17, 18, 20
tokenizing, 112, 113, 134, 139, 141
Slater, 22, 23
Train_X_Tfidf, 93
Support Vector Machine , 1, 33
vektor, 92, 148, 150, 157, 158, 160, 161, 162
SVM, 1, 2, 3, 4, 8, 9, 12, 21, 25, 26, 27, 28,
Vektorisasi, 92, 148, 158 29, 30, 32
Vektorisasi Word, 92 variabel independent, 30
WordCloud, 146 vektor, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 17, 18,
bidang, 1, 2, 3, 8, 13, 15, 16, 17, 31 19, 20, 26, 27, 31, 32
box constraint, 29 banknote, 7
data, 1, 2, 3, 4, 9, 10, 12, 13, 14, 22, 25, 27, BN, 2, 3, 4, 7, 8, 20
28, 29, 30, 31, 32 CM, 1, 2, 3, 4, 11, 12
derau, 27, 30 confusion matrix, 10, 19, 20
dual Wolfe, 24, 27, 29 Confusion Matrix, 1
hyperplane, 1, 2, 3, 4, 8, 9, 10, 11, 12, 13, 14, Decision Tree, 4, 9
15, 16, 17, 18, 19, 20, 21, 25, 26, 29
DecisionTreeClassifier, 9, 11, 19
kendala , 14, 15, 16, 21, 22, 24, 26, 27, 28, 29,
DecisionTreeRegressor, 12, 14, 15
30
klasifikasi, 1, 4, 6, 9, 12
kernel, 24, 25
laju benar positif, 2, 3, 20
konveks, 22, 23, 27
laju error, 1, 2, 3, 20
Lagrange, 21, 22, 24, 26, 27
Laju salah positif, 20
 Indeks 347

misklasifikasi, 2, 3, 12, 20 Stemmer, 18

missclassification, 1 SVM, 25
POHON KEPUTUSAN, 1 TF-IDF, 19, 24
regresi, 1, 4, 6, 12, 13 Tokenization, 15, 21
ROC, 4 word_tokenize, 15, 17, 20, 22, 38, 39, 68, 69,
SML, 4 70, 79, 82

spesifitas, 3, 4, 20
Supervised Machine Learning, 4
Wavelet, 8
Colab, 1, 2
Corona, 1
Covid-19, 1, 3, 4, 5, 6, 7, 8, 9, 11, 26, 28, 29,
31, 32, 33, 34, 35, 45, 46, 47, 48
klasterisasi, 32, 33, 34
Machine Learning, 1, 9, 32, 35, 43, 47
Python, 1
SARS-CoV-2, 1
SVR, 1, 32, 36, 43
visualisasi, 9, 35, 47
Amazon Review, 19, 25
corpus, 1, 3, 6, 7, 8, 10, 11, 12, 14, 15, 16, 17,
19, 20, 24, 29, 38
Lemmatization, 18
Machine Learning, 3, 19, 107
Naive Bayes, 24, 25, 27, 99
Natural Language Process, 1, 14
NLP, 1, 2, 3, 4, 6, 7, 14, 15
NLTK, 6, 15, 16, 38
pre-processing, 18
 TENTANG PENULIS

Hanna Arini Parhusip adalah staf dosen sejak tahun 2020 di

Magister Sains Data, Fakultas Sains dan Matematika (FSM),
Universitas Kristen Satya Wacana (UKSW), Salatiga dengan
jenjang Lektor Kepala. Sebelumnya sebagai staf pengajar di
Jurusan Matematika pada fakultas yang sama sejak 1994. Gelar
Doktor diperoleh tahun 2005 dari Departemen Matematika,
Fakultas Matematika dan Ilmu Pengetahuan Alam, Institut Teknologi
Bandung melalui Sandwich Program dengan Universitas Teknologi
Kaiserslautern dan ITB. Fokus penelitiannya adalah matematika
terapan termasuk pemodelan matematika dan optimisasi di mana
pada 2 tahun ini mengembangkan manfaat data science pada monitoring gas-gas rumah
kaca melalui kegiatan Matching Fund, serta menjabat sebagai ketua di tahun 2021- 2022;
menghasilkan 4 hak cipta di tahun pertama dan 1 hak cipta di tahun kedua. Selain itu, dokumen
engineering design terkait produk yang dibuat ada 2 buku nasional dalam proses review dan 1
jurnal telah terbit. Selain hasil penelitian, kegiatan penelitian diintegrasikan kepada mahasiswa
FSM, FTI, dan FTEK. Penulis telah menerbitkan lebih dari 10 jurnal internasional bereputasi/
prosiding internasional bereputasi; 19 buku ber-ISBN yang di antaranya 5 buku terkait dengan
pemodelan, optimasi, dan 2 buku bahasa Inggris dengan contoh pemodelan data dari berbagai
usaha kecil.
Beberapa buku diterbitkan oleh Penerbit ANDI, di antaranya berjudul Pemrograman Python
untuk Penanganan Big Data (2019) dan Mathematical Art untuk BATIMA dan ODEMA dengan
Software Surfer (2020). Beberapa penelitian dan jurnal yang dihasilkan, maupun buku dan
produk hak cipta yang dibuat tercatat di Sinta. Penjelasan di atas selengkapnya ditunjukkan
di https://sinta.kemdikbud.go.id/authors/profile/9411/?page=2&view=researches dengan
ORCHID ID: https://orcid.org/0000-0002-0129-830X dan SINTA ID: 9411.