Belajar Machine Learning tanpa ribet, Project Pertama dengan Iris data set di Python

Kali ini saya akan membagikan pengalaman pertama belajar Machine Learning yang menurut saya sangat tepat guna. Tidak ba bi bu, tidak runyam, langsung dengan studi kasus yang dapat dipahami dengan mudah dan dapat memberikan gambaran jelas tentang bagaimana konsep Machine Learning.

Biasanya, yang membuat seorang pemula jadi ketakutan belajar Machine Learning adalah karena terlalu banyak teorema, algoritma, rumus-rumus yang nampak horor sekali.

Ketika kita mempelajari buku-buku mengenai Machine Learning, itu pun kita disuguhkan dengan konsep-konsep statistik yang sudah tentu membuat pemula seperti kita muak seketika, dan langsung kepingin beli minyak angin karena kepala mulai retak.

Bagaimana cara mempelajari Machine Learning dengan lebih mudah dan cepat?

Seperti yang teman-teman tau, saya adalah seorang web developer. Saya mencoba mengaplikasikan bagaimana cara saya belajar pemrograman web dulu untuk mempelajari Machine Learning.

Bagaimana caranya? Yaitu dengan mengerjakan sebuah project! Ya, dengan mengerjakan sebuah project, kita akan mendapat gambaran menyeluruh tentang bagaimana proses dari Machine Learning. Ini yang saya alami.

Sebelumnya saya tidak mengerti apa-apa mengenai Machine Learning, bahkan, selama setahun terakhir saya melakukan pendekatan dengan membeli buku dan membaca berbagai macam tutorial, itu sama saja. Kosong.

Dulu sewaktu saya memulai belajar webdev juga begitu, mulanya begitu sulit dan abstrak. Tapi setelah memulai mengerjakan project sederhana, gambaran itu mulai nampak, harapan itu mulai ada. Eaa.

Project sederhana membantu kita mendapatkan gambaran menyeluruh

Seperti saya bilang tadi, dengan mengerjakan project, meskipun itu sebuah project sederhana, kita akan mendapat gambaran tentang yang sedang kita kerjakan.

Memang, ini memakan waktu, tapi perjalanan kita akan lebih terarah (karena kita memiliki goal), dan kita akan belajar perlahan tanpa kita sadari kita sedang belajar. Lhoh?

Iya, betul. Misalnya, kita akan belajar membuat Pecel. Kalau kita membaca buku teorema-teorema, kita akan disuguhkan berbagai macam hal mengenai sayuran, bumbu dapur, dan semacamnya, tapi kita tak bisa mendapatkan gambaran tentang bagaimana proses terjadinya Pecel.

Kita harus mendapatkan resep, dan memulai memasak. Ketika kita memulai memasak, kita akan pelan-pelan mempelajari tentang sayuran juga, bumbu juga, namun hanya yang kita butuhkan, jadi tidak akan terllau banyak, dan itu sambil jalan, jadi akan memangkas waktu. Kedepan, mungkin kita bisa belajar sayuran yang lain di lain waktu. Sampai disini, kita sepemikiran?

Ya, kita akan memulai memasak. Dan, tulisan ini semoga bisa menjadi buku resep pertama teman-teman untuk memulai membuat Pecel eh Machine Learning maksud saya.

Proses memasak Pecel dalam Machine Learning

Ketika kita akan memasak pecel, kita akan tentunya akan memulai dengan menyiapkan sayuran sebagai bahan, bumbu-bumbu, alat-alat, dan memulai proses dengan merebus sayuran dan seterusnya.

Bagiaman dengan Machine Learning? Secara umum, kita dapat mengklasifikasikan proses tersebut dalam tahapan berikut ini:

Dapat gambaran? Ya, santai saja. Kita akan memasak pecel, bukan memasak daging kambing yang super ribet. Yok mulai yok.

Bahan Utama: sayuran Iris data set

Project yang akan kita buat disini bisa dibilang sebagai project yang pas banget bagi pemula. Boleh dibilang semacam Hello World! dalam Machine Learning.

Bahan yang kita perlukan adalah data. Dan, pada project ini kita akan menggunakan Iris data set. Mengenai Iris data set, teman-teman bisa membaca di tulisan saya sebelumnya: Apa itu iris data set? Link tersebut akan membuka tab baru, jangan khawatir kehilangan halaman ini 🙂

Mulai Memasak!

Yep, mari kita mulai memasak. Untuk kasus kali ini, secara umum yang akan kita lakukan adalah:

  1. Menginstall Python dan beberapa library pendukung
  2. Meload data
  3. Membaca data set
  4. Memvisualisasikan data set
  5. Mengevaluasi beberapa algoritma
  6. Membuat prediksi

1. Menginstall Python dan beberapa library yang dibutuhkan

Saya tidak akan mengajari bagaimana teman-teman menginstal Python, atau library-library yang dibutuhkan. Silahkan teman-teman buka tab baru, kemudian buka Google, kemudian cari bagaimana cara install Python. Versinya bebas, teman-teman bisa menggunakan Python 2.7.* atau Python 3.6.* keatas.

Saya sendiri menyarankan teman-teman menggunakan Python versi 3. Kenapa? Karena seperti yang dirilis dari situs resmi Python, katanya akhir tahun ini Python 2.7 akan deprecated, alias mati, alias sudah tidak didukung lagi. Sebagai persiapan jangka panjang, sebaiknya install Python3.

1.1. Library-library yang harus diinstall

Setelah beres urusan install Python, sekarang saatnya install library-library pendukungnya:

Sekali lagi, untuk urusan install library diatas, teman-teman silahkan buka tab baru, kemudian cari di Google. Setelah kelar, balik kesini lagi dan cek versi library untuk memastikan semua alat sudah siap.

1.2. Cek versi library pendukung

Saya sudah menyiapkan script cek_versi.py yang dapat teman-teman jalankan dengan mengetikan #python3 cek_versi.py pada terminal jika di Linux, atau untuk di Windows/Mac bisa menyesuaikan.

# Python version
import sys
print('Python: {}'.format(sys.version))
# scipy
import scipy
print('scipy: {}'.format(scipy.__version__))
# numpy
import numpy
print('numpy: {}'.format(numpy.__version__))
# matplotlib
import matplotlib
print('matplotlib: {}'.format(matplotlib.__version__))
# pandas
import pandas
print('pandas: {}'.format(pandas.__version__))
# scikit-learn
import sklearn
print('sklearn: {}'.format(sklearn.__version__))

Silahkan kopi-pasta kemudian jalankan skrip tersebut. Pastikan tidak ada error. Jika ada error, kemungkinan ada library yang dibutuhkan namun belum terinstall. Silahkan kopi-pasta error nya di Google.

Jika installasi semua alat sudah siap, tampilannya kurang lebih akan seperti ini:

Result cek_versi.py

Bisa jadi untuk versi yang teman-teman miliki berbeda, ndak masalah, yang penting pastiin dulu installasinya berhasil semua.

2. Meload data

2.1. Import Semua Library

Teman-teman bisa memulai dengan membuat file python baru, katakanlah iris.py atau apapun itu.

Kemudian, masukkan skrip berikut dalam file tersebut. Kemudian silahkan di run untuk ngetes.

# Load libraries
from pandas import read_csv
from pandas.plotting import scatter_matrix
from matplotlib import pyplot
from sklearn.model_selection import train_test_split
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import StratifiedKFold
from sklearn.metrics import classification_report
from sklearn.metrics import confusion_matrix
from sklearn.metrics import accuracy_score
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC

Skrip diatas digunakan untuk mengimport library-library yang nantinya kita butuhkan untuk memulai project ini. Harusnya, kalau semua sudah berjalan dengan baik, teman-teman tidak menemui error ketika merunning skrip tersebut.

2.2. Meload data set

Kita akan meload data set Iris yang sudah kita bicarakan diawal. Kita dapat meloadnya langsung dari reponya, bisa juga temen-temen download csv nya kemudian temen-temen arahkan url ke lokal komputer temen-temen.

Tambahkan skrip dibawah dibawah skrip yang tadi.

# Load dataset
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/iris.csv"
names = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'class']
dataset = read_csv(url, names=names)

Kita menggunkan Pandas untuk meload data, nantinya juga kita bakalan gunain Pandas lagi untuk melakukan beberapa explorasi yang maybe menarik. Seperti statistik deskriptif dan visualisasi data.

Pada skrip diatas, juga dapat dilihat kalau kita menspesifikkan nama-nama dalam variable names, sehingga memudahkan nanti ketika kita akan membaca datanya.

3. Membaca data set

Well, saat ini waktunya kita mengintip masakan kita yang masih berada dalam baskom. Kita bakalan:

3.1 Melihat dimensi data set

Kopi-pasta skrip berikut dibawah skrip sebelumnya, dan jalankan skripnya.

# shape
print(dataset.shape)

Resultnya adalah 150 instance dengan 5 atribut:

3.2 Menampilkan data yang supaya enak dibaca

Seperti sebelumnya, skripnya:

# head
print(dataset.head(20))

Nanti akan muncul seperti ini:

Lebih enak dibaca kan?

3.3. Menampilkan ringkasan statistik

Skripnya:

print(">>Statistical Summary")
# descriptions
print(dataset.describe())

Munculnya:

3.4. Distribusi Kelas

Skripnya:

print(">>Class Distribution")
# class distribution
print(dataset.groupby('class').size())

Munculnya:

4. Visualisasi Data

Sekarang kita sudah ada sedikit gambaran mengenai Pecel Machine Learning dan bagiamana memasaknya. Paling tidak, sampai disini sudah sedikit keren.

Namun, itu belum cukup. Kita perlu memvisualisasikan data yang kita miliki. Kita akan coba membuat 2 jenis plot.

  1. Unvariate plot, untuk dapat memahami masing-masing atribut
  2. Multivariate plot, supaya kita dapat memahami relasi atau hubungan dari setiap atribut.

4.1. Unvariate Plots

Pada bagian ini, kita akan menvisualisasikan data seacara individu dari masing-masing atribut.

Masih seperti yang tadi, tambahkan saja dibawah skrip sebelumnya skrip berikut:

# box and whisker plots
dataset.plot(kind='box', subplots=True, layout=(2,2), sharex=False, sharey=False)
pyplot.show()

Selain result dari result sebelumnya muncul, akan muncul popup image seperti dibawah:

Kita juga bisa menampilkanya dalam bentuk histogram untuk lebih memahami bagaimana distribusi datanya dengan skrip berikut:

# histograms
dataset.hist()
pyplot.show()

Munculnya akan seperti ini:

4.2. Multivariate Plots

Dengan menggunakan plot ini, kita dapat melihat interaksi dari setiap atribut. Relasi-relasi yang membuat mereka berhubungan akan dapat digambarkan dalam matriks. Skripnya dibawah ini:

# scatter plot matrix
scatter_matrix(dataset)
pyplot.show()

Munculnya:

Kalau kita lihat diagram diatas, grouping secara diagonal seperti itu mengindikasikan adanya korelasi atau keterkaitan yang tinggi dari setiap variable dan relasinya dapat kita prediksi.

5. Mengevaluasi Beberapa Algoritma

Kita telah berhasil memvisualisasikan data, selanjutnya dengan menggunakan beberapa algoritma, kita akan coba untuk membuat beberapa model data dan mendapatkan mengestimasi akurasi dari data yang tidak terlihat.

5.1. Membuat validasi data set

Kenapa kita perlu melakukan validasi data set? Karena, kita perlu memastikan bahwa model yang akan kita buat itu bagus.

Kemudian, kita akan menggunakan metode statistik untuk mengestimasi akurasi dari model yang akan kita buat untuk menemukan data yang belum dapat dilihat.

Maksud dari data yang belum dapat dilihat ini adalah informasi-informasi yang mungkin dapat kita pelajari dari pola suatu data.

Dengan melakukan validasi data set, kita dapat memilih data-data yang tidak perlu dibaca oleh algoritma dan kita akan melakukan ini karena sangat menentukan seberapa akurat dan bagus model yang nantinya akan kita buat.

Kita akan membagi dataset kedalam dua bagian, 80% akan kita gunakan untuk training, evaluasi dan menentukan model kita, 20% akan kita gunakan untuk memvalidasi dataset.

# scatter plot matrix
scatter_matrix(dataset)
pyplot.show()

Sekarang kita memiliki data dalam X_train dan Y_train untuk mempersiapkan model yang akan dibuat, dan X_validation dan Y_validation set akan kita gunakan nanti.

5.2. Test Harness

Kita akan menggunakan statified 10-fold cross validation untuk mengestimasi akurasi dari modelnya.

Hal ini akan membagi dataset menjadi 10 bagian, tranining pada 9 bagian dan tes pada 1 bagian, dan akan berulang untuk semua kombinasi.

Stratified berarti setiap bagian dari dataset akan memiliki distribusi yang sama dari contoh berdasarkan kelas yang sudah ada pada training dataset.

# Test options and evaluation metric
kfold = StratifiedKFold(n_splits=10, random_state=1)
cv_results = cross_val_score(model, X_train, Y_train, cv=kfold, scoring='accuracy')

5.3. Build Models

Kita tidak tau model yang mana yang akan menjadi model paling bagus untuk kasus ini, juga belum bisa tau bagaimana konfigurasi yang cocok untuk digunakan.

Balik lagi ke diagram sebelumnya, yang menenjukan setiap kelas linier dalam beberapa dimensi, kita dapat memperkirakan secara umum untuk bagaimana hasil yang nantinya akan bagus.

Haduh, mulai pusing. Okey, baiklah. Sampai disini, saya lupa mengingatkan. Ketika kita menemui istilah yang sulit, atau kita belum ngeh, ada baiknya kita buka tab baru dan Googling lagi.

Sempatkan untuk sejenak membaca sembari belajar, hal ini akan memudahkan kita untuk memahami. Tanpa kita sadari, kita jadi belajar lebih banyak.

Balik ke laptop, kita tentukan 6 algoritma yang akan kita gunakan untuk kasus ini:

Beberapa algoritma diatas sudah mewakili berbagai macam algoritma yang ada untuk bahan kita belajar dan memprediksi hasil dari kasus ini. LR dan LDA yang termasuk simple linier. KNN, CART, NB dan SVM termasuk dalam algoritma non linier. Komplit.

Then, kita mulai klunak-kluniknya:

# Spot Check Algorithms
models = []
models.append(('LR', LogisticRegression(solver='liblinear', multi_class='ovr')))
models.append(('LDA', LinearDiscriminantAnalysis()))
models.append(('KNN', KNeighborsClassifier()))
models.append(('CART', DecisionTreeClassifier()))
models.append(('NB', GaussianNB()))
models.append(('SVM', SVC(gamma='auto')))
# evaluate each model in turn
results = []
names = []
for name, model in models:
	kfold = StratifiedKFold(n_splits=10, random_state=1)
	cv_results = cross_val_score(model, X_train, Y_train, cv=kfold, scoring='accuracy')
	results.append(cv_results)
	names.append(name)
	print('%s: %f (%f)' % (name, cv_results.mean(), cv_results.std()))

5.4. Memilih model yang terbaik

Sekarang kita memiliki 6 model berbeda dan hasil berupa estimasi akurasi dari masing-masing algoritma yang kita gunakan. Kita perlu membandingkan setiap model dan memilih mana yang memiliki akurasi tertinggi.

Hasil dari contoh skrip diatas, kita akan mendapatkan:

LR: 0.960897 (0.052113)
LDA: 0.973974 (0.040110)
KNN: 0.957191 (0.043263)
CART: 0.957191 (0.043263)
NB: 0.948858 (0.056322)
SVM: 0.983974 (0.032083)

Hasilnya yang temen-temen dapat mungkin bisa jadi berbeda. Pada kasus ini, kita mendapatkan model dengan algoritma SVM memiliki skor akurasi tertinggi yaitu 0.98 atau 98%.

Kita juga dapat membuat hasil evaluasi dalam bentuk plot dan membandingkan spreadnya, dan mean dari akurasi setiap model. Ini adalah populasi akurasi dari setiap algoritma yang telah kita evaluasi selama 10 kali (tadi loh waktu 10 fold-cross validation).

Cara terbaik untuk membandingkan sample dari hasil setiap algoritma adalah dengan membuat box and whisker plot dari setiap distribusi dan membandingkan distribusinya. Hasilnya dikasus ini serperti:

Kita dapat melihat gambar diatas (box and whisker plots) semuaya berada di titik atas dari range yang ada, dengan berbagai macam evaluasi mendapatkan 100% akurasi, dan beberapa turun sampai 80% tingkat akurasinya.

5.5. Full source code untuk step 5

# compare algorithms
from pandas import read_csv
from matplotlib import pyplot
from sklearn.model_selection import train_test_split
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import StratifiedKFold
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
# Load dataset
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/iris.csv"
names = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'class']
dataset = read_csv(url, names=names)
# Split-out validation dataset
array = dataset.values
X = array[:,0:4]
y = array[:,4]
X_train, X_validation, Y_train, Y_validation = train_test_split(X, y, test_size=0.20, random_state=1)
# Spot Check Algorithms
models = []
models.append(('LR', LogisticRegression(solver='liblinear', multi_class='ovr')))
models.append(('LDA', LinearDiscriminantAnalysis()))
models.append(('KNN', KNeighborsClassifier()))
models.append(('CART', DecisionTreeClassifier()))
models.append(('NB', GaussianNB()))
models.append(('SVM', SVC(gamma='auto')))
# evaluate each model in turn
results = []
names = []
for name, model in models:
	kfold = StratifiedKFold(n_splits=10, random_state=1)
	cv_results = cross_val_score(model, X_train, Y_train, cv=kfold, scoring='accuracy')
	results.append(cv_results)
	names.append(name)
	print('%s: %f (%f)' % (name, cv_results.mean(), cv_results.std()))
# Compare Algorithms
pyplot.boxplot(results, labels=names)
pyplot.title('Algorithm Comparison')
pyplot.show()

6. Membuat Prediksi

Kita harus menentukan algoritma yang akan kita gunakan untuk membuat prediksi. Bagaimana cara menentukannya? Caranya adalah dengan melihat dari proses sebelumnya.

Pada proses sebelumnya, kita dapati bahwa SVM adalah model yang memiliki tingkat akurasi tertinggi. Kita akan menggunakan model dengan algoritma SVM ini sebagai final modelnya.

Sebelumnya kan kita menggunakan data training, dan kita masih memiliki data validasinya yang 20%. Kita akan melihat akurasi model yang ktia buat berdasarkan data validasi tersebut.

Hal ini kita lakukan untuk memastikan akurasi dari model yang tadi kita dapati sebagai model yang terbaik.

6.1. Membuat prediksi

Kita akan membuat prediksi berdasarkan validation dataset.

# Make predictions on validation dataset
model = SVC(gamma='auto')
model.fit(X_train, Y_train)
predictions = model.predict(X_validation)

6.2. Mengevaluasi Prediksi

Kita dapat mengevaluasi prediksi kita dengan membandingkan dengan hasil dari validation set tadi, kemudian menghitung akurasi dari klasifikasinya, dalam bentuk confusion matrix dan classification report.

# Evaluate predictions
print(accuracy_score(Y_validation, predictions))
print(confusion_matrix(Y_validation, predictions))
print(classification_report(Y_validation, predictions))

Kita dapat melihat bahwa akurasi adalah 0.966 atau 96%.

Akhirnya bau-bau pecel Machine Learning sudah mulai menguap wkwkw. Hasil dari classification report adalah breakdown dari setiap kelas berdasrkan precision, recall, f1-score, dan support showing excellent results.

0.9666666666666667
[[11  0  0]
 [ 0 12  1]
 [ 0  0  6]]
                 precision    recall  f1-score   support

    Iris-setosa       1.00      1.00      1.00        11
Iris-versicolor       1.00      0.92      0.96        13
 Iris-virginica       0.86      1.00      0.92         6

       accuracy                           0.97        30
      macro avg       0.95      0.97      0.96        30
   weighted avg       0.97      0.97      0.97        30

6.3. Full Source Code

# make predictions
from pandas import read_csv
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from sklearn.metrics import confusion_matrix
from sklearn.metrics import accuracy_score
from sklearn.svm import SVC
# Load dataset
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/iris.csv"
names = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'class']
dataset = read_csv(url, names=names)
# Split-out validation dataset
array = dataset.values
X = array[:,0:4]
y = array[:,4]
X_train, X_validation, Y_train, Y_validation = train_test_split(X, y, test_size=0.20, random_state=1)
# Make predictions on validation dataset
model = SVC(gamma='auto')
model.fit(X_train, Y_train)
predictions = model.predict(X_validation)
# Evaluate predictions
print(accuracy_score(Y_validation, predictions))
print(confusion_matrix(Y_validation, predictions))
print(classification_report(Y_validation, predictions))

Penutup

Pada intinya, kita belajar itu memang memerlukan proses. Tidak ada belajar yang tidak ribet, bahakn rebahan aja kadang ada something yang bikin ribet.

Pesan untuk saya pribadi dan teman-teman, kita telah menyelesaikan project sederhana ini DENGAN MACHINE LEARNING. Keren bukan? Namun, tentunya pengetahuan kita masih sangat dangkal. Masih banyak hal yang tidak kita ketahui dan belum bisa kita pahami.

Ada baiknya untuk kita mencatat hal-hal yang masih tabu tersebut, dan kita berusaha untuk mencari jawabannya. Bisa dengan googling, baca buku, atau bertanya kepada experts yang ada disekitar kita. Paling tidak, kita sudah memiliki gambaran mengenai bagaimana memasak pecel memproses dataset dengan Machine Learning di Python.

Python juga bukan bahasa yang terlalu sulit, andaikata teman-teman sudah pernah mengenal bahasa pemrograman lain, sebenarnya mirip-mirip. Mungkin harus diperhatikan di indentasinya kalau di Python.

Big thanks to Jason Brownlee yang telah membuat tulisan yang menjadi referensi utama tulisan ini, dan telah membuka wawasan saya dan banyak orang yang awam tentang Machine Learning menjadi lebih mudah untuk mendapatkan gambaran.

Sekian, semangat belajar, sampai lupa caranya menyerah!