Pengantar Machine Learning di Python

Anda akan mengimplementasikan KNN pada dataset Iris yang terkenal.

Catatan: Anda mungkin ingin mempertimbangkan untuk mengikuti kursus Machine Learning dengan Python atau untuk latar belakang tentang bagaimana ML berkembang dan banyak lagi, pertimbangkan untuk membaca pos ini.

Pendahuluan

Machine Learning berkembang dari ilmu komputer yang terutama mempelajari perancangan algoritme yang dapat belajar dari pengalaman. Untuk belajar, algoritme memerlukan data yang memiliki atribut tertentu yang menjadi dasar pencarian pola prediktif yang bermakna. Secara umum, tugas ML dapat dikategorikan sebagai pembelajaran konsep, klastering, pemodelan prediktif, dan sebagainya. Tujuan akhir algoritme ML adalah mampu mengambil keputusan dengan benar tanpa campur tangan manusia. Memprediksi saham atau cuaca merupakan beberapa aplikasi dari algoritme machine learning.

Ada berbagai algoritme machine learning seperti decision tree, Naive Bayes, random forest, support vector machine, K-nearest neighbor, K-means clustering, dll.

Dari kelas algoritme machine learning, yang akan Anda gunakan hari ini adalah k-nearest neighbor.

Sekarang, pertanyaannya adalah apa sebenarnya algoritme K-Nearest Neighbor itu, mari kita cari tahu!

Apa itu k-Nearest Neighbor?

KNN atau algoritme k-nearest neighbor adalah algoritme pembelajaran terawasi; maksud diawasi adalah memanfaatkan label kelas dari data pelatihan selama fase pembelajaran. Ini adalah algoritme machine learning berbasis instance, di mana titik data baru diklasifikasikan berdasarkan instance (titik data) berlabel yang tersimpan. KNN dapat digunakan untuk klasifikasi dan regresi; namun, lebih sering digunakan untuk tujuan klasifikasi.

Variabel k dalam KNN adalah variabel krusial yang juga dikenal sebagai hiperparameter yang membantu mengklasifikasikan titik data dengan akurat. Lebih tepatnya, k adalah jumlah tetangga terdekat yang ingin Anda ambil suaranya saat mengklasifikasikan titik data baru.

Anda dapat melihat saat nilai k meningkat dari 1 ke 7, batas keputusan antara dua kelas dengan beberapa titik data menjadi lebih halus.

Sekarang pertanyaannya adalah bagaimana semua “keajaiban” ini terjadi, di mana setiap kali ada titik data baru, ia diklasifikasikan berdasarkan titik data yang tersimpan?

Jadi, mari kita pahami dengan cepat melalui langkah-langkah berikut:

• Pertama, Anda memuat semua data dan menginisialisasi nilai k,
• Kemudian, jarak antara titik data yang tersimpan dan titik data baru yang ingin Anda klasifikasikan dihitung menggunakan berbagai metrik kemiripan atau jarak seperti jarak Manhattan (L1), jarak Euclidean (L2), cosine similarity, jarak Bhattacharyya, jarak Chebyshev, dll.
• Selanjutnya, nilai jarak diurutkan baik menurun maupun menaik dan k-tetangga terdekat teratas atau terbawah ditentukan.
• Label dari k-tetangga terdekat dikumpulkan, dan voting mayoritas atau voting berbobot digunakan untuk mengklasifikasikan titik data baru. Titik data baru diberi label kelas berdasarkan titik data tertentu yang memiliki skor tertinggi dari semua titik data yang tersimpan.
• Akhirnya, kelas yang diprediksi untuk instance baru dikembalikan.

Prediksi dapat berupa dua jenis: klasifikasi di mana label kelas diberikan ke titik data baru atau regresi di mana suatu nilai diberikan ke titik data baru. Berbeda dengan klasifikasi, pada regresi, rata-rata dari semua k-tetangga terdekat diberikan ke titik data baru.

Kekurangan KNN: Pertama, kompleksitas dalam mencari tetangga terdekat untuk setiap titik data baru. Kedua, menentukan nilai k terkadang menjadi tugas yang melelahkan. Terakhir, juga tidak jelas jenis metrik jarak mana yang sebaiknya digunakan saat menghitung tetangga terdekat.

Cukup teori, bukan? Jadi, mari kita muat, analisis, dan pahami data yang akan Anda gunakan dalam tutorial singkat hari ini.

Memuat Data Iris

Dataset Iris terdiri dari 150 sampel dengan tiga kelas yaitu Iris-Setosa, Iris-Versicolor, dan Iris-Virginica. Empat fitur/atribut yang berkontribusi untuk mengidentifikasi secara unik sebagai salah satu dari tiga kelas adalah sepal-length, sepal-width, petal-length, dan petal-width.

Silakan gunakan dataset publik lain atau dataset pribadi Anda.

Sklearn adalah pustaka machine learning Python yang banyak digunakan untuk tugas-tugas data science. Pustaka ini memiliki berbagai algoritme klasifikasi, regresi, dan klastering termasuk support vector machines, random forests, gradient boosting, k-means, KNN, dll. Di bawah sklearn ada pustaka bernama datasets yang berisi banyak dataset untuk berbagai tugas termasuk dataset Iris, semua dataset ini dapat dimuat langsung. Cukup intuitif dan mudah. Jadi, mari kita segera memuat dataset iris.

from sklearn.datasets import load_iris

load_iris memiliki data dan label kelas untuk setiap sampel. Mari kita ekstrak semuanya dengan cepat.

data = load_iris().data

Variabel data akan berupa array numpy berbentuk (150,4) yang memiliki 150 sampel masing-masing dengan empat atribut berbeda. Setiap kelas memiliki 50 sampel.

data.shape

(150, 4)

Mari ekstrak label kelasnya.

labels = load_iris().target

labels.shape

(150,)

Selanjutnya, Anda harus menggabungkan data dan label kelasnya, dan untuk itu, Anda akan menggunakan pustaka Python yang sangat baik bernama NumPy. NumPy menambahkan dukungan untuk array dan matriks besar multi-dimensi, bersama dengan koleksi fungsi matematika tingkat tinggi yang luas untuk mengoperasikan array ini. Jadi, mari kita impor cepat!

import numpy as np

Karena data adalah array 2-d, Anda juga harus mengubah bentuk labels menjadi array 2-d.

labels = np.reshape(labels,(150,1))

Sekarang, Anda akan menggunakan fungsi concatenate yang tersedia di pustaka numpy, dan Anda akan menggunakan axis=-1 yang akan menggabungkan berdasarkan dimensi kedua.

data = np.concatenate([data,labels],axis=-1)

data.shape

(150, 5)

Berikutnya, Anda akan mengimpor pustaka analisis data Python bernama pandas yang berguna saat Anda ingin menyusun data dalam bentuk tabel dan melakukan beberapa operasi serta manipulasi pada data. Secara khusus, pustaka ini menawarkan struktur data dan operasi untuk memanipulasi tabel numerik dan deret waktu.

Dalam tutorial hari ini, Anda akan menggunakan pandas cukup ekstensif.

import pandas as pd

names = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'species']

dataset = pd.DataFrame(data,columns=names)

Sekarang, Anda memiliki data frame dataset yang memiliki data & label kelas yang Anda butuhkan!

Sebelum melanjutkan lebih jauh, ingat bahwa variabel labels memiliki label kelas sebagai nilai numerik, tetapi Anda akan mengonversi nilai numerik tersebut menjadi nama bunga atau spesies.

Untuk melakukan ini, Anda akan memilih hanya kolom class dan mengganti masing-masing dari tiga nilai numerik dengan spesies yang sesuai. Anda akan menggunakan inplace=True yang akan memodifikasi data frame dataset.

dataset['species'].replace(0, 'Iris-setosa',inplace=True)
dataset['species'].replace(1, 'Iris-versicolor',inplace=True)
dataset['species'].replace(2, 'Iris-virginica',inplace=True)

Mari cetak lima baris pertama dari dataset dan lihat tampilannya!

dataset.head(5)

Analisis Data Anda

Mari kita cepat cari tahu bagaimana ketiga bunga tersebut terlihat saat divisualisasikan dan seberapa berbeda satu sama lain, bukan hanya dalam angka tetapi juga secara nyata!

(Sumber)

Mari visualisasikan data yang Anda muat di atas menggunakan scatterplot untuk mengetahui seberapa besar satu variabel dipengaruhi oleh variabel lain atau katakanlah seberapa besar korelasi antara dua variabel.

Anda akan menggunakan pustaka matplotlib untuk memvisualisasikan data menggunakan scatterplot.

import matplotlib.pyplot as plt

Tip: Tertarik mempelajari berbagai cara memvisualisasikan data di Python? Lihat kursus Introduction to data visualization with matplotlib.

plt.figure(4, figsize=(10, 8))

plt.scatter(data[:50, 0], data[:50, 1], c='r', label='Iris-setosa')

plt.scatter(data[50:100, 0], data[50:100, 1], c='g',label='Iris-versicolor')

plt.scatter(data[100:, 0], data[100:, 1], c='b',label='Iris-virginica')

plt.xlabel('Sepal length',fontsize=20)
plt.ylabel('Sepal width',fontsize=20)
plt.xticks(fontsize=20)
plt.yticks(fontsize=20)
plt.title('Sepal length vs. Sepal width',fontsize=20)
plt.legend(prop={'size': 18})
plt.show()

Dari plot di atas, terlihat jelas bahwa terdapat korelasi tinggi antara bunga Iris setosa terkait panjang sepal dan lebar sepal. Di sisi lain, terdapat korelasi yang lebih rendah antara Iris versicolor dan Iris virginica. Titik data pada versicolor & virginica lebih menyebar dibandingkan dengan setosa yang lebih rapat.

Mari dengan cepat juga memplot grafik untuk petal-length dan petal-width.

plt.figure(4, figsize=(8, 8))

plt.scatter(data[:50, 2], data[:50, 3], c='r', label='Iris-setosa')

plt.scatter(data[50:100, 2], data[50:100, 3], c='g',label='Iris-versicolor')

plt.scatter(data[100:, 2], data[100:, 3], c='b',label='Iris-virginica')
plt.xlabel('Petal length',fontsize=15)
plt.ylabel('Petal width',fontsize=15)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.title('Petal length vs. Petal width',fontsize=15)
plt.legend(prop={'size': 20})
plt.show()

Bahkan untuk petal-length dan petal-width, grafik di atas menunjukkan korelasi yang kuat untuk bunga setosa yang berkerumun rapat.

Berikutnya, untuk lebih memvalidasi klaim tentang bagaimana petal-length dan petal-width berkorelasi, mari plot matriks korelasi untuk ketiga spesies.

dataset.iloc[:,2:].corr()

Tabel di atas menandakan korelasi kuat sebesar 0.96 untuk petal-length dan petal-width ketika ketiga spesies digabungkan.

Mari juga analisis korelasi antara ketiga spesies secara terpisah.

dataset.iloc[:50,:].corr() #setosa

dataset.iloc[50:100,:].corr() #versicolor

dataset.iloc[100:,:].corr() #virginica

Dari ketiga tabel di atas, cukup jelas bahwa korelasi antara petal-length dan petal-width dari setosa dan virginica masing-masing adalah 0.33 dan 0.32. Sedangkan untuk versicolor sebesar 0.78.

Selanjutnya, mari visualisasikan distribusi fitur dengan memplot histogram:

fig = plt.figure(figsize = (8,8))
ax = fig.gca()
dataset.hist(ax=ax)
plt.show()

petal-length, petal-width, dan sepal-length menunjukkan distribusi unimodal, sedangkan sepal-width menunjukkan semacam distribusi Gaussian. Semua ini adalah analisis yang berguna karena kemudian Anda dapat mempertimbangkan untuk menggunakan algoritme yang bekerja baik dengan jenis distribusi seperti ini.

Berikutnya, Anda akan menganalisis apakah keempat atribut berada pada skala yang sama atau tidak; ini adalah aspek penting dari ML. Data frame pandas memiliki fungsi bawaan bernama describe yang memberikan count, mean, max, min dari data dalam format tabel.

dataset.describe()

Anda dapat melihat bahwa keempat atribut memiliki skala serupa antara 0 & 8 dan dalam satuan sentimeter; jika Anda mau, Anda dapat menurunkannya lagi ke antara 0 dan 1.

Walaupun Anda sudah tahu bahwa ada 50 sampel per kelas, yaitu ~33,3% dari total distribusi, tetap saja mari kita cek ulang!

print(dataset.groupby('species').size())

species
Iris-setosa        50
Iris-versicolor    50
Iris-virginica     50
dtype: int64

Prapemrosesan Data Anda

Setelah memuat data dan menganalisisnya secara ekstensif, saatnya menyiapkan data Anda yang kemudian dapat Anda berikan ke model ML Anda. Pada bagian ini, Anda akan melakukan prapemrosesan data dengan dua cara: menormalkan data dan membagi data menjadi set pelatihan dan pengujian.

Menormalkan data Anda

Ada dua cara untuk menormalkan data Anda:

• Normalisasi contoh yaitu Anda menormalkan setiap sampel secara individual,
• Normalisasi fitur yaitu Anda menormalkan setiap fitur dengan cara yang sama di seluruh sampel.

Sekarang pertanyaannya adalah mengapa atau kapan Anda perlu menormalkan data? Dan apakah Anda perlu menstandarkan data Iris?

Jawabannya hampir selalu ya. Merupakan praktik yang baik untuk menormalkan data karena membawa semua sampel ke skala dan rentang yang sama. Menormalkan data sangat penting ketika data yang Anda miliki tidak konsisten. Anda dapat memeriksa inkonsistensi dengan menggunakan fungsi describe() yang Anda pelajari di atas yang akan memberikan nilai max dan min. Jika nilai max dan min dari satu fitur jauh lebih besar daripada fitur lainnya maka menormalkan kedua fitur ke skala yang sama sangatlah penting.

Misalkan X adalah satu fitur dengan rentang lebih besar dan Y adalah fitur kedua dengan rentang lebih kecil. Maka, pengaruh fitur Y dapat tertutupi oleh pengaruh fitur X. Dalam kasus seperti itu, menjadi penting untuk menormalkan kedua fitur X dan Y.

Pada data Iris, normalisasi tidak diperlukan.

Mari cetak fungsi describe() lagi dan lihat mengapa Anda tidak memerlukan normalisasi apa pun.

dataset.describe()

Atribut sepal-length memiliki nilai dari 4,3 hingga 7,9 dan sepal-width berisi nilai dari 2 hingga 4,4, sementara nilai petal-length berkisar dari 1 hingga 6,9 dan petal-width berkisar dari 0,1 hingga 2,5. Nilai semua fitur berada dalam rentang 0,1 hingga 7,9, yang dapat Anda anggap dapat diterima. Maka, Anda tidak perlu menerapkan normalisasi apa pun pada dataset Iris.

Membagi data

Ini adalah aspek penting lainnya dari machine learning karena tujuan Anda adalah membuat model yang cukup andal untuk dapat mengambil keputusan atau mengklasifikasikan data dalam lingkungan pengujian tanpa campur tangan manusia. Oleh karena itu, sebelum menerapkan model ML Anda di industri, Anda perlu memastikan bahwa model dapat melakukan generalisasi dengan baik pada data pengujian.

Untuk tujuan ini, Anda memerlukan set pelatihan dan pengujian. Kembali ke data Iris, Anda memiliki 150 sampel, Anda akan melatih model ML pada 80% data dan 20% data sisanya akan digunakan untuk pengujian.

Dalam data science, Anda akan sering menjumpai istilah Overfitting yang berarti model Anda mempelajari data pelatihan dengan sangat baik tetapi gagal berkinerja pada data pengujian. Jadi, membagi data menjadi set pelatihan dan pengujian atau validasi sering kali membantu Anda mengetahui apakah model Anda overfitting atau tidak.

Untuk pembagian set pelatihan dan pengujian, Anda akan menggunakan pustaka sklearn yang memiliki fungsi pembagian bawaan bernama train_test_split. Jadi, mari kita bagi datanya.

from sklearn.model_selection import train_test_split

train_data, test_data, train_label, test_label = train_test_split(dataset.iloc[:,:3], dataset.iloc[:,3], test_size=0.2, random_state=42) 

Perhatikan bahwa random_state adalah seed yang menerima random_state sebagai masukan; jika Anda mengubah angkanya, pembagian data juga akan berubah. Namun, jika Anda menjaga random_state tetap sama dan menjalankan sel beberapa kali, pembagian data akan tetap tidak berubah.

Mari kita cepat cetak bentuk data pelatihan dan pengujian beserta labelnya.

train_data.shape,train_label.shape,test_data.shape,test_label.shape

((120, 3), (120,), (30, 3), (30,))

Akhirnya, saatnya memberi data ke algoritme k-nearest neighbor!

Model KNN

Setelah semua proses pemuatan, analisis, dan prapemrosesan data, kini saatnya Anda memasukkan data ke dalam model KNN. Untuk melakukan ini, Anda akan menggunakan fungsi bawaan sklearn bernama neighbors yang memiliki kelas KNeigborsClassifier di dalamnya.

Mari mulai dengan mengimpor classifier.

from sklearn.neighbors import KNeighborsClassifier

Catatan: parameter k (n_neighbors) sering kali menggunakan angka ganjil untuk menghindari hasil seri pada skor voting.

Untuk memutuskan nilai terbaik bagi hiperparameter k, Anda akan melakukan sesuatu yang disebut grid-search. Anda akan melatih dan menguji model pada 10 nilai k yang berbeda dan akhirnya menggunakan yang memberikan hasil terbaik.

Mari inisialisasi variabel neighbors(k) yang akan memiliki nilai dari 1–9 dan dua matriks nol numpy yaitu train_accuracy dan test_accuracy masing-masing untuk akurasi pelatihan dan pengujian. Anda akan membutuhkannya nanti untuk memplot grafik guna memilih nilai neighbor terbaik.

neighbors = np.arange(1,9)
train_accuracy =np.zeros(len(neighbors))
test_accuracy = np.zeros(len(neighbors))

Potongan kode berikut adalah tempat semua “keajaiban” terjadi. Anda akan melakukan enumerate atas kesembilan nilai neighbor dan untuk setiap neighbor Anda kemudian memprediksi baik pada data pelatihan maupun pengujian. Terakhir, simpan akurasinya dalam array numpy train_accuracy dan test_accuracy.

for i,k in enumerate(neighbors):
    knn = KNeighborsClassifier(n_neighbors=k)

    #Fit the model
    knn.fit(train_data, train_label)

    #Compute accuracy on the training set
    train_accuracy[i] = knn.score(train_data, train_label)

    #Compute accuracy on the test set
    test_accuracy[i] = knn.score(test_data, test_label)

Berikutnya, Anda akan memplot akurasi pelatihan dan pengujian menggunakan matplotlib; dengan grafik accuracy vs. varying number of neighbors Anda akan dapat memilih nilai k terbaik di mana model Anda berkinerja paling baik.

plt.figure(figsize=(10,6))
plt.title('KNN accuracy with varying number of neighbors',fontsize=20)
plt.plot(neighbors, test_accuracy, label='Testing Accuracy')
plt.plot(neighbors, train_accuracy, label='Training accuracy')
plt.legend(prop={'size': 20})
plt.xlabel('Number of neighbors',fontsize=20)
plt.ylabel('Accuracy',fontsize=20)
plt.xticks(fontsize=20)
plt.yticks(fontsize=20)
plt.show()

Dari grafik di atas, tampaknya saat n_neighbors=3, keduanya memberikan performa terbaik. Jadi, mari tetapkan n_neighbors=3 dan jalankan ulang pelatihannya.

knn = KNeighborsClassifier(n_neighbors=3)

#Fit the model
knn.fit(train_data, train_label)

#Compute accuracy on the training set
train_accuracy = knn.score(train_data, train_label)

#Compute accuracy on the test set
test_accuracy = knn.score(test_data, test_label)

Mengevaluasi Model Anda

Pada segmen terakhir tutorial ini, Anda akan mengevaluasi model pada data pengujian menggunakan beberapa teknik seperti confusion_matrix dan classification_report.

Mari periksa terlebih dahulu akurasi model pada data pengujian.

test_accuracy

0.9666666666666667

Voila! Tampaknya model mampu mengklasifikasikan 96,66% data pengujian dengan benar. Keren, bukan? Hanya dengan beberapa baris kode, Anda dapat melatih model ML yang kini mampu memberi tahu Anda nama bunga hanya dengan menggunakan empat fitur dengan akurasi 96,66%. Siapa tahu mungkin performanya jauh lebih baik daripada manusia.

Confusion Matrix

Confusion matrix terutama digunakan untuk menggambarkan performa model Anda pada data uji yang nilai atau label benarnya diketahui.

Scikit-learn menyediakan fungsi yang menghitung confusion matrix untuk Anda.

prediction = knn.predict(test_data)

Fungsi plot_confusion_matrix() berikut telah dimodifikasi dan diambil dari sumber ini.

import itertools
def plot_confusion_matrix(cm, classes,
                          normalize=False,
                          title='Confusion matrix',
                          cmap=plt.cm.Blues):


    plt.imshow(cm, interpolation='nearest', cmap=cmap)
    plt.title(title)
    plt.colorbar()
    tick_marks = np.arange(len(classes))
    plt.xticks(tick_marks, classes, rotation=45)
    plt.yticks(tick_marks, classes)

    fmt = '.2f' if normalize else 'd'
    thresh = cm.max() / 2.
    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
        plt.text(j, i, format(cm[i, j], fmt),
                 horizontalalignment="center",
                 color="white" if cm[i, j] > thresh else "black")

    plt.ylabel('True label',fontsize=30)
    plt.xlabel('Predicted label',fontsize=30)
    plt.tight_layout()
    plt.xticks(fontsize=18)
    plt.yticks(fontsize=18)
class_names = load_iris().target_names


# Compute confusion matrix
cnf_matrix = confusion_matrix(test_label, prediction)
np.set_printoptions(precision=2)

# Plot non-normalized confusion matrix
plt.figure(figsize=(10,8))
plot_confusion_matrix(cnf_matrix, classes=class_names)
plt.title('Confusion Matrix',fontsize=30)
plt.show()

Dari plot confusion_matrix di atas, Anda dapat mengamati bahwa model mengklasifikasikan semua bunga dengan benar kecuali satu bunga virginica yang diklasifikasikan sebagai bunga versicolor.

Classification Report

Classification report membantu Anda mengidentifikasi kelas yang salah klasifikasi dengan lebih rinci dengan memberikan precision, recall, dan F1 score untuk setiap kelas. Anda akan menggunakan pustaka sklearn untuk memvisualisasikan classification report.

from sklearn.metrics import classification_report

print(classification_report(test_label, prediction))

                 precision    recall  f1-score   support

    Iris-setosa       1.00      1.00      1.00        10
Iris-versicolor       0.90      1.00      0.95         9
 Iris-virginica       1.00      0.91      0.95        11

      micro avg       0.97      0.97      0.97        30
      macro avg       0.97      0.97      0.97        30
   weighted avg       0.97      0.97      0.97        30

Lanjutkan Lebih Jauh!

Pertama-tama selamat kepada semua yang berhasil sampai akhir! Namun ini baru permulaan. Masih panjang perjalanan ke depan!

Tutorial ini terutama membahas dasar-dasar machine learning dan implementasi salah satu jenis algoritme ML yang dikenal sebagai KNN dengan Python. Dataset Iris yang Anda gunakan cukup kecil dan agak sederhana.

Jika tutorial ini menumbuhkan minat Anda untuk belajar lebih jauh, Anda dapat mencoba menggunakan dataset lain atau mempelajari lebih banyak algoritme ML dan mungkin menerapkannya pada dataset Iris untuk mengamati pengaruhnya terhadap akurasi. Dengan cara ini Anda akan belajar jauh lebih banyak daripada sekadar memahami teori!

Jika Anda sudah cukup bereksperimen dengan dasar-dasar yang disajikan dalam tutorial ini dan algoritme machine learning lainnya, Anda mungkin ingin melangkah lebih jauh ke Python dan analisis data.