Learning Vector Quantization dengan Python

Kita akan membuat model Learning Vector Quantization dengan Python di Google Colab. Jadi, pastikan kalian mempunyai akun google sebelum mengikuti tutorial kali ini.

Pertama kita buat file di google colab dengan klik halaman berikut https://colab.research.google.com/#create=true

Pada link tersebut nantinya akan dialihkan ke dalam file ipynb di google colab. Selanjutnya kita buka google drive, lalu buat folder dengan nama dataset. Nantinya di folder tersebut akan menyimpan dataset yang akan kita gunakan dalam proses klasifikasi dengan Learning Vector Quantization.

Untuk datasetnya kita akan mengambil di kaggle yaitu Crop Recommendation Dataset. Download dataset Crop Recommendation Dataset di kaggle, kemudian upload dataset tersebut di folder dataset google drive yang barusan kita buat.

Import Libraries

Selanjutnya, kita buka kembali file notebook google colab dan buat code baru. Pada code tersebut kita akan melakukan import libraries python yang akan digunakan dalam proses klasifikasi dengan learning vector quantization seperti code dibawah ini.

import numpy as np
import pandas as pd
from sklearn.preprocessing import LabelEncoder 
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix, accuracy_score, classification_report

Data Preparation

Setelah kita import semua library yang akan digunakan, lalu kita akan melakukan tahapan persiapan data. Kita akan menghubungkan file notebook google colab kita dengan google drive.

from google.colab import drive
drive.mount('/content/drive')

Jika sudah terhubung, kita akan load dataset Crop Recommendation menggunakan pandas yang berada di google drive pada folder dataset yang telah dibuat tadi. Kita akan menampilkan 5 data pertama pada dataset tersebut.

df = pd.read_csv('/content/drive/My Drive/dataset/Crop_recommendation.csv')
df.head()

Kemudian, kita akan menampilkan descriptive statistics pada dataset tersebut.

df.describe()

Lalu, kita juga akan mengecek jumlah kolom dan baris yang dimiliki dataset Crop Recommendation

df.shape

Data Cleaning

Setelah tahapan persiapan data selesai, kita akan masuk ke tahapan pembersihan data. Pembersihan data ini bertujuan untuk menghapus atau memperbaiki keselahan pada dataset yang akan kita gunakan.

Untuk tahapan pembersihan data/data cleaning yang pertama yaitu kita akan menampilkan data yang memiliki nilai atau missing value.

df.isnull().sum()

Karena hasil untuk setiap kolom adalah 0, maka tidak ada missing value. Oleh karena itu, kita bisa lanjut ke tahapan pengecekan duplicate value.

df.duplicated().sum()

Pada dataset yang kita gunakan tidak ada duplicate value. Jadi, kita akan masuk ke tapahan selanjutnya yaitu kita akan mengecek type data pada setiap kolom dataset.

df.info()

Selanjutnya kita akan menghitung jumlah label/class pada dataset.

# Unique Name of the Crops in Dataset
crops = df['label'].unique()
crops.sort()
print ("Total Number of Crops Data: ", len(crops) )
print("\n","-"*20, " List of Crops ", "-"*20)
crops.tolist()

Terakhir, kita hitung jumlah data pada setiap label/class pada dataset.

# Number of Rows against each Crop
print("Number of Records Against Eash Crop")
print("-"*35)
print(df['label'].value_counts() )

Label Encoder

Selanjutnya, kita akan masuk ke tahapan label encoder untuk mengubah label/class pada dataset yang sebelumnya bertipe categorical menjadi numerical dengan menggunakan bantuan LabelEncoder(). Terakhir kita akan menyimpan hasil encoder ke dalam kolom baru yaitu label_codes.

labelencoder= LabelEncoder() # initializing an object of class LabelEncoder

# Fit and Transforming the label column.
df['label_codes'] = labelencoder.fit_transform(df['label']) 
df

Set Independent & Dependent Values

Setelah itu, kita akan mengambil kolom yang akan digunakan sebagai independent values dan dependent values. Untuk independent values akan dimasukan ke dalam variable x dan akan mengambil data pada kolom N, P, K, temperature, humadity, ph, dan rainfall.

# Features Selection
selected_features = {'N', 'P', 'K', 'temperature', 'humidity', 'ph', 'rainfall'}
selected_features

Sedangkan, untuk dependent values kita akan masukan ke dalam variable y yang akan mengambil data pada kolom label_codes.

X = df[selected_features] # Independent Values
y = df['label_codes'] # Targeted Values Selection

Splitting the dataset into the Training set and Test set

Kita akan memisah kembali dataset menjadi data training dan data testing dengan pembagian 70:30. 70% untuk data training dan 30% untuk data testing.

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=19)

Feature Scaling

Untuk mendapatkan hasil akurasi yang lebih optimal, kita perlu melakukan feature scaling agar rentang nilai pada setiap kolom tidak terlalu jauh. Ada berbagai macam cara feature scaling, untuk kali ini kita akan menggunakan MinMaxScaler(). MinMaxScaler akan membuat nilai pada setiap kolom berada pada rentang 0 sampai 1.

mms = MinMaxScaler()

X_train = mms.fit_transform(X_train)
X_test = mms.transform(X_test)

Create Model Learning Vector Quantization

Kita akan masuk ke dalam tahapan pembuat model Learning Vector Quantization. Untuk yang pertama kita akan memasukan nilai X_train, X_test, y_train, dan y_test pada np.array()

X_train = np.array(X_train)
X_test = np.array(X_test)
y_train = np.array(y_train)
y_test = np.array(y_test)

Selanjutnya, kita akan memasukan nilai n_input dan n_output. Untuk n_input akan mengambil jumlah kolom. Sedangkan n_ouput akan mengambil jumlah class/label.

n_input = X_train.shape[1]
n_output = len(np.unique(y_train))

print('Input Neuron:', n_input)
print('Output Neuron:', n_output)

Untuk membuat model LVQ disini kita akan membuat class terlebih dahulu. Lalu didalam class tersebut berisi fungsi yang akan digunakan dalam melatih maupun memprediksi data degan LVQ.

Pada proses train bobot awal yang digunakan dipilih dengan cara mengambil nilai pertama pada setiap class dan bukan dengan cara clustering.

class LVQ(object):

    def __init__(self, sizeInput, sizeOutput, max_epoch, learning_rate, fungsi_pembelajaran):
        """
        Inisialisasi class (constructor)
        :param sizeInput (int): Banyaknya input neuron sesuai dengan banyaknya parameter (fitur pada data latih)
        :param sizeOutput (int): Banyaknya output neuron sesuai dengan banyaknya label (kelas pada data latih)
        :param max_epoch (int): Maksimal epoch yang diizinkan
        :param alpha (float): learning rate
        """

        self.sizeInput = sizeInput
        self.sizeOutput = sizeOutput
        self.max_epoch = max_epoch
        self.alpha = learning_rate
        self.fungsi_pembelajaran = fungsi_pembelajaran
        self.weight = np.zeros((sizeOutput, sizeInput))

    def getWeight(self):
        """
        Mendapatkan bobot jaringan LVQ setelah proses training

        :return: weight (nilai bobot)
        """

        return self.weight

    def train(self,train_data,train_target):
        """
        Proses pelatihan jaringan LVQ
        :param train_data (numpy array atau pandas dataframe): Matriks yang berisi data latih
        :param train_target (numpy array atau pandas series): Array yang berisi label dari data latih
        :return: bobot dan label
        """

        weight_label, label_index = np.unique(train_target, True)

        # Inisialisasi bobot
        self.weight = train_data[label_index].astype(np.float)

        # Hapus data yang digunakan untuk inisialisasi bobot
        train_data = np.delete(train_data, label_index, axis=0)
        train_target = np.delete(train_target, label_index, axis=0)

        epoch = 0
        iterasi = 0
        
        while epoch <= self.max_epoch:
            epoch += 1
            for data, target in zip(train_data, train_target):
                iterasi += 1
                distance = np.sqrt(np.sum((data - self.weight) ** 2, axis=1))
                idx_min = np.argmin(distance)

                if target == weight_label[idx_min]:
                    self.weight[idx_min] = self.weight[idx_min] + self.alpha * (data - self.weight[idx_min])
                else:
                    self.weight[idx_min] = self.weight[idx_min] - self.alpha * (data - self.weight[idx_min])

            self.alpha = self.alpha - (self.fungsi_pembelajaran * self.alpha)

        weight_class = (self.weight, weight_label)
        return weight_class

    def test(self, test_data, weight_class):
        """
        Proses pengujian jaringan LVQ
        :param test_data (numpy array atau pandas dataframe): Matriks yang berisi data uji
        :param weight_class (tuple): Tuple yang berisi pasangan bobot dan labelnya
        :return: Nilai prediksi label/class
        """

        weight, label = weight_class
        output = []
        for data in test_data:
            distance = np.sqrt(np.sum((data - self.weight) ** 2, axis=1))
            idx_min = np.argmin(distance)
            output.append(label[idx_min])

        return output

Train Model Learning Vector Quantization

Setelah model Learning Vector Quantization dibuat, kita bisa melakukan training data. Untuk yang pertama kita panggil class LVQ dengan mengirimkan paramater sizeInput, sizeOutput, max_epoch, learning_rate, dan fungsi pembelajaran. Untuk max_epoch, learning_rate dan fungsi pembelajaran masih kita pilih secara manual.

Setelah itu, kita bisa langsung panggil fungsi train pada class lvq dan kita juga akan mengirimkan dua parameter untuk proses training data yaitu X_train dan y_train.

Setelah proses training data selesai, kita bisa mengetahui bobot akhir dengan memanggil fungsi lvq.getWeight() untuk mendapatkan bobot akhir.

lvq = LVQ(sizeInput=n_input, sizeOutput=n_output, max_epoch=3, learning_rate=0.3, fungsi_pembelajaran=0.1)
bobot_dan_label = lvq.train(X_train, y_train)
bobot = lvq.getWeight()

print('Bobot: ', bobot)
print('Ukuran Bobot:', bobot.shape)

Predict the Test set results

Kemudian, kita akan melakukan prediksi pada data testing dan disini kita mendapatkan akurasi sebesar 92%.

# Testing
y_pred = lvq.test(X_test, bobot_dan_label)
print('Accuracy:', accuracy_score(y_test, y_pred))

Model Evaluation

Kita juga melakukan model evaluation dengan menggunakan confusion matrix dan juga classification report.

print(confusion_matrix(y_pred, y_test))

print(classification_report(y_pred, y_test))

LVQ with NeuPy

Sebenarnya, ada library yang menyediakan model klasifikasi dengan Learning Vector Quantization yaitu Neupy. Pada Neupy tidak hanya menyediakan LVQ 1, disana juga menyediakan LVQ 2, LVQ 2.1, dan LVQ 3.

Untuk cara menggunakan NeuPy, kita perlu mengiinstall library tersebut dengan cara berikut.

!pip install neupy

Setelah itu, kita import algorithms dari neupy. Lalu masukan data X_train, X_test, y_train dan y_test ke dalam np.array(). Kemudian, kita bisa panggil LVQ yang akan menerima parameter input dan classes.

Jika sudah kita bisa lakukan train yang mengirim parameter untuk training data dan juga maksimal epoch yang akan digunakan. Terakhir, kita bisa lakukan prediksi pada data testing. Untuk akurasi model LVQ dengan NeuPy yaitu 93%. 1% diatas model LVQ yang kita buat secara manual.

from neupy import algorithms

X_train = np.array(X_train)
X_test = np.array(X_test)
y_train = np.array(y_train)
y_test = np.array(y_test)
n_input = X_train.shape[1]
n_output = len(np.unique(y_train))

lvqnet = algorithms.LVQ(n_inputs=n_input, n_classes=n_output)
lvqnet.train(X_train, y_train, epochs=3)

y_pred = lvqnet.predict(X_test)
print('Accuracy:', accuracy_score(y_test, y_pred))

Kita juga bisa menggunakan LVQ2 pada library NeuPy. Untuk caranya kurang lebih sama seperti diatas. Sedangkan untuk hasil akurasi dengan menggunakan LVQ 2 yaitu 94%.

lvqnet = algorithms.LVQ2(n_inputs=n_input, n_classes=n_output)
lvqnet.train(X_train, y_train, epochs=3)

y_pred = lvqnet.predict(X_test)
print('Accuracy:', accuracy_score(y_test, y_pred))