Prediksi diabetes dengan K-NN

Referensi : https://www.kaggle.com/uciml/pima-indians-diabetes-database/code

[KEMBALI KE MENU SEBELUMNYA]

DAFTAR ISI

1. Tujuan

2. Alat dan Bahan

3. Dasar Teori

4. Percobaan

5. Video

6. Link Download

                1. Tujuan [back]
1. Memprediksi apakah seseorang terkena penyakit diabetes berdasarkan beberapa parameter lain pendukung

                2. Alat dan Bahan [back]
Alat yang digunakan pada pembelajaran ini adalah python pada percobaan ini kita menggunakan vscode sebagai platform open sourcenya

                3. Dasar Teori [back]

Python

python dibuat pertama kali oleh Guido van Rossum di tahun 1991. Saat ini ada 2 versi, yaitu python 2 dan python 3. Versi yang terbaru adalah versi yang ketiga.

Python dapat digunakan sebagai berikut :

1. Pengembangan aplikasi web dan seluler back end (atau sisi server)
2. Pengembangan aplikasi atau perangkat lunak untuk dekstop
3. Memproses data besar dan melakukan perhitungan matematis
4. Menulis skrip sistem (membuat instruksi yang memberitahu sistem komputer untuk “melakukan” sesuatu)

Algoritma K-Nearest Neighbors

Kita akan mencari kelas pada titik bintang biru. Bintang biru tersebut dapat dikategorikan sebagai kelas RC  atau  GS. K pada algoritma KNN merupakan nilai yang kita tentukan. Misalkan K = 3. Sekarang kita akan membuat lingkaran dengan BS sebagai titik tengah yang berdekataan dengan 3 titik poin.

3 poin terdekat dari BS adalah RC. Oleh karena itu  dengan confidence level yang baik kita dapat menyatakan BS masuk pada kelas RC.  Disini pemilihan sangat menentukan dari totok terdekat dari  tetangga dari RC. Pemilihan hyperparameter K akan menjadi sangat krusial 

Menentukan Nilai K

Kita akan memahami bagaimana nilai K akan mempengaruhi algoritma ini.  Pada contoh terdapat 6 observasi  training yang  konstan dengan nilai K yang memberikan pembatas setiap kelas. Pemabatasini akan membedakan RC dari GS. Kita akan coba melihat perbedaan  dari nilai K terhadap kelas

Jika kita perhatikan maka pembatas akan menjadi lebih halus dengan peningkatan nilai K. Jika K ditingkatkan hingga tak hingga maka semuanya akan menjadi biru ata merah bergantung pada jumlah total.

Error training dan  validasi error rate merupakan parameter yang perlu diberikan dengan berbagai nilai K yang berbeda. Berikut merupakan kurva training error rate dengan berbagai nilai K

Berdasarakan grafik tersebut dapat kita lihat. Error rate  ketika K = 1 akan  selalu nol pada sampel training. Ini karena  poin terdekat dengan datapoint adalah dirinya sendiri. Oleh karena itu prediksi ketika K = 1 akan selalu akurat. Jika kurva validasi error sama maka pilihan K yang terbaik adalah 1. Berikut kurva validasi error dengan perbedaan nilai K.

Sehingga ketika K = 1 kita mendapatkan overvitting pada pembatas.  Sehingga errorrate akan menurun dan mencapai minima. Setelah minima  error rate  akan meningkat sesuai dengan nilai K. Untuk mendapat nilai K  yang optimal maka kita akan memisahkan training dana validasi dari dataset.

Perlu juga dicatat bahwa ketiga ukuran jarak hanya berlaku untuk variabel kontinu. Dalam contoh variabel kategori, jarak Hamming harus digunakan. Ini juga memunculkan masalah standarisasi variabelnumerik antara 0 dan 1 ketika ada campuran variabel numerik dan kategoris dalam dataset.

                  4. Percobaan (Contoh) [back]

Program:

# Import Library yang perlu digunakan

import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

import seaborn as sns

# Membaca dataset dan merubah ke dataframe

data_diabetes = pd.read_csv('diabetes.csv')

data_diabetes

# Melihat informasi dataframe

data_diabetes.info()

# Melihat statistik data

data_diabetes.describe()

# Melihat data yang bernilai NULL

data_diabetes.isnull().sum()

# EDA

data_diabetes.corr()

# Visualisasi Korelasi

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

sns.heatmap(data_diabetes.corr(), annot =True)

from sklearn.preprocessing import StandardScaler

sc_X = StandardScaler()

X =  pd.DataFrame(sc_X.fit_transform(data_diabetes.drop(["Outcome"],axis = 1),),

        columns=['Pregnancies', 'Glucose', 'BloodPressure', 'SkinThickness', 'Insulin',

       'BMI', 'DiabetesPedigreeFunction', 'Age'])

X

y = data_diabetes.Outcome

y

#importing train_test_split

from sklearn.model_selection import train_test_split

X_train,X_test,y_train,y_test = train_test_split(X,y,train_size=0.8,test_size = 0.2 , random_state=42, stratify=y)

from sklearn.neighbors import KNeighborsClassifier

test_scores = []

train_scores = []

for i in range(1,15):

    knn = KNeighborsClassifier(i)

    knn.fit(X_train,y_train)

    

    train_scores.append(knn.score(X_train,y_train))

    test_scores.append(knn.score(X_test,y_test))

## score that comes from testing on the same datapoints that were used for training

max_train_score = max(train_scores)

train_scores_ind = [i for i, v in enumerate(train_scores) if v == max_train_score]

print('Max train score {} % and k = {}'.format(max_train_score*100,list(map(lambda x: x+1, train_scores_ind))))

## score that comes from testing on the datapoints that were split in the beginning to be used for testing solely

max_test_score = max(test_scores)

test_scores_ind = [i for i, v in enumerate(test_scores) if v == max_test_score]

print('Max test score {} % and k = {}'.format(max_test_score*100,list(map(lambda x: x+1, test_scores_ind))))

plt.figure(figsize=(12,5))

p = sns.lineplot(x = (range(1,15)),y = train_scores,marker='*',label='Train Score')

p = sns.lineplot(x = (range(1,15)),y = test_scores,marker='o',label='Test Score')

#Setup a knn classifier with k neighbors

knn = KNeighborsClassifier(12)

knn.fit(X_train,y_train)

knn.score(X_test,y_test)

# Performance Analysis

#import confusion_matrix

from sklearn.metrics import confusion_matrix

#let us get the predictions using the classifier we had fit above

y_pred = knn.predict(X_test)

confusion_matrix(y_test,y_pred)

pd.crosstab(y_test, y_pred, rownames=['True'], colnames=['Predicted'], margins=True)

y_pred = knn.predict(X_test)

from sklearn import metrics

cnf_matrix = metrics.confusion_matrix(y_test, y_pred)

p = sns.heatmap(pd.DataFrame(cnf_matrix), annot=True, cmap="YlGnBu" ,fmt='g')

plt.title('Confusion matrix', y=1.1)

plt.ylabel('Actual label')

plt.xlabel('Predicted label')

#import classification_report

from sklearn.metrics import classification_report

print(classification_report(y_test,y_pred))

#import GridSearchCV

from sklearn.model_selection import GridSearchCV

#In case of classifier like knn the parameter to be tuned is n_neighbors

param_grid = {'n_neighbors':np.arange(1,50)}

knn = KNeighborsClassifier()

knn_cv= GridSearchCV(knn,param_grid,cv=5)

knn_cv.fit(X,y)

print("Best Score:" + str(knn_cv.best_score_))

print("Best Parameters: " + str(knn_cv.best_params_))   

Hasil :

                5. Video [back]

Tutorial Google Colab

Tutorial  Pengklasifikasian Diabetes

  

                  6. Link Download [back]

Dowload Code Python : download

Download Data Set    : download