Membuat Portofolio Data Science untuk Prediksi Diabetes dengan Metode K-Nearest Neighbors (KNN)

Pendahuluan

Data Science telah merevolusi cara kita mendekati masalah kompleks, menawarkan tools dan teknik yang kuat untuk mengekstrak insight berharga dari data. Dalam modul ini, kita akan menjelajahi dunia analitik prediktif dengan membuat portofolio data science yang berfokus pada prediksi diabetes menggunakan algoritma K-Nearest Neighbors (KNN).

Started

Untuk memulai project ini, pertama-tama kita perlu menyiapkan work space. Kita akan menggunakan berbagai Library dan dependensi Python untuk memudahkan analisis nantinya. Kita dapat menggunakan IDE seperti Visual Studio Code atau PyCharm. Namun lebih direkomendasikan untuk menggunakan Jupyter Notebook ataupun Google Collab.

from mlxtend.plotting import plot_decision_regions
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
sns.set()
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline

Load Dataset

Selanjutnya adalah load dataset. Kita dapat menggunakan library pandas untuk memuat dataset yang kita punya ke dalam working space.

# panggil dataset
diabetes_data = pd.read_csv('/content/drive/MyDrive/AMCC/diabetes.csv')
#Tampilkan 5 data teratas
diabetes_data.head()

Output :

Dataset yang digunakan dalam project kali ini menyediakan informasi tentang variabel-variabel berikut:

• Pregnancies: Jumlah kehamilan yang pernah dialami oleh individu.
• Glucose: Tingkat glukosa dalam plasma darah (kadar gula dalam darah) yang diukur dalam mg/dL.
• BloodPressure: Tekanan darah sistolik dalam mmHg (millimeter of mercury).
• SkinThickness: Ketebalan lipatan kulit pada area trisep (dalam satuan mm).
• Insulin: Tingkat insulin dalam serum (dalam satuan mu U/ml).
• BMI (Body Mass Index): Indeks massa tubuh yang dihitung sebagai berat badan dalam kilogram dibagi oleh kuadrat tinggi badan dalam meter persegi.
• DiabetesPedigreeFunction: Nilai yang menggambarkan riwayat diabetes dalam keluarga.
• Age: Usia individu.

Dataset ini akan menjadi dasar analisis dan pembangunan model prediksi diabetes menggunakan algoritma K-Nearest Neighbors (KNN) dalam modul ini. Selanjutnya, kita akan melakukan Exploratory Data Analysis (EDA) untuk mendapatkan wawasan yang lebih mendalam tentang data ini.

Exploratory Data Analysis (EDA)

Sebelum memulai pembangunan model, kita akan melakukan EDA mendalam untuk mendapatkan wawasan tentang hubungan antara berbagai fitur dan dampaknya terhadap diabetes. Langkah ini sangat penting untuk memahami pola-pola yang mendasar di dalam data.

Kita memulai EDA dengan memanggil info() pada dataset. Ini memberikan informasi penting tentang jumlah entri, tipe data, dan apakah terdapat nilai yang hilang (missing values) pada setiap kolom. Informasi ini penting untuk memahami integritas data.

diabetes_data.info()

Output :

Berikutnya, kita menggunakan describe() untuk mendapatkan statistik deskriptif dari dataset. Ini mencakup count, mean, standard deviation, minimum, quartiles, dan maximum dari setiap kolom numerik. Informasi ini memberikan gambaran umum tentang distribusi dan variasi data.

diabetes_data.describe()

output :

Lalu kita akan melihat dimensi dari dataset yang kita punya dengan diabetes_data.shape. Informasi ini memungkinkan kita untuk memahami sejauh mana data ini terdistribusi dan apakah ada potensi untuk transformasi atau pemrosesan lebih lanjut.

diabetes__data.shape

output :

Memproses data yang hilang (Null)

Ketika bekerja dengan dataset, seringkali kita akan menemui kolom-kolom di mana beberapa baris memiliki nilai yang kosong atau hilang. Untuk memastikan integritas dan keandalan data, kita perlu mengisi celah ini dengan nilai yang sesuai. Dalam hal ini, kita menggunakan metode imputasi rata-rata.

diabetes_data['Glucose'].fillna(diabetes_data['Glucose'].mean(), inplace=True)
diabetes_data['SkinThickness'].fillna(diabetes_data['SkinThickness'].mean(), inplace=True)
diabetes_data['BloodPressure'].fillna(diabetes_data['BloodPressure'].mean(), inplace=True)
diabetes_data['Insulin'].fillna(diabetes_data['Insulin'].mean(), inplace=True)
diabetes_data['BMI'].fillna(diabetes_data['BMI'].mean(), inplace=True)

Kode di atas menjalankan proses untuk mengisi nilai yang hilang dalam beberapa kolom penting. Mari kita lihat lebih dekat:

• diabetes_data1[‘Glucose’].fillna(diabetes_data1[‘Glucose’].mean(), inplace=True): Kita mengambil kolom “Glucose” dan menggunakan metode .fillna() untuk mengisi nilai yang hilang. Di sini, kita menggunakan rata-rata dari seluruh data pada kolom “Glucose” sebagai nilai pengganti.
• Kita melakukan langkah yang serupa untuk kolom-kolom lain seperti “SkinThickness”, “BloodPressure”, “Insulin”, dan “BMI”. Setiap kolom mendapatkan nilai penggantian berupa rata-rata dari data di kolom tersebut.
• inplace=True memastikan bahwa perubahan dilakukan di tempat (di dataset asli) dan tidak menghasilkan salinan baru.

Setelah memproses data yang hilang, kita memeriksa kembali dimensi dari dataset untuk memastikan bahwa tidak ada baris yang dihapus dan jumlah data tetap konsisten dengan perintah diabetes_data1.shape

dibetes_data.shape

Visualisasi Distribusi Data

Untuk melihat Distribusi Data dapat menggunakan visualisasi histogram. Histogram adalah pemetaan frekuensi bilangan dari deret observasi berdasarkan rumus.

Dimana:
n adalah jumlah bilangan yang ditemukan pada masing-masing deret bin,
i adalah observasi pada deret bin,
k adalah total number of bin,
m adalah bin.

Namun kita dapat menggunakan library matplotlib untuk menampilkan visualisasi histogram dengan perintah :

plot = diabetes_data.hist(fisize = (20,20))

Dengan melihat persebaran data dengan histogram kita juga dapat melihat anomali terhadap data yang kita punya. Jika diagram yang dihasilkan tidak menunjukan simetris distribusi.

Feature Selection

Feature Selection adalah pemilihan subset fitur dari sekumpulan fitur yang tersedia dalam dataset untuk digunakan dalam analisis atau pemodelan data. Tujuannya adalah untuk mengidentifikasi dan memilih fitur-fitur yang paling relevan dan signifikan untuk tujuan analisis atau pemodelan, sambil mengabaikan yang kurang penting. Untuk memilih fitur yang paling relevan biasanya digunakan diagram heat map untuk melihat korelasi antar feature.

Berikut code untuk melakukan visualisasi heatmap:

plt.figure(figsize=(12,10))
p=sns.heatmap(diabetes_data.corr(),annot=True, cmap='RdYlGn')

Diagram diatas menunjukan korelasi antar fitur dalam rentang nilai -1 sampai 1. Jika hasil bernilai positif maka korelasi antar feature adalah positif yang artinya searah. Namun, jika hasil bernilai negatif maka korelasi antar fitur saling berkebalikan. Dengan diagram heatmap kita dapat tahu mana feature yang dapat kita pilih untuk dilakukan tahap pemodelan.

Standard Scaling

Standard scaling, juga dikenal sebagai z-score normalization atau standardization, adalah salah satu teknik dalam preprocessing data yang digunakan untuk mengubah nilai-nilai dalam dataset sehingga memiliki rata-rata (mean) 0 dan deviasi standar (standard deviation) 1. Tujuan utama dari standard scaling adalah untuk membuat data memiliki distribusi yang sesuai dengan nilai-nilai yang memiliki mean dan deviasi standar yang serupa.

Rumus standar scaling untuk suatu fitur x adalah sebagai berikut:

Beberapa manfaat ketika menerapkan standar scaling. Memudahkan perbandingan: Mengubah semua fitur ke skala yang sama memudahkan perbandingan antara fitur dan memungkinkan untuk lebih mudah menilai hubungan relatif antara fitur-fitur. Meningkatkan kinerja model: Banyak algoritma pembelajaran mesin, seperti regresi linear dan K-Nearest Neighbors (K-NN), sangat dipengaruhi oleh skala data. Dengan melakukan standard scaling kita dapat meningkatkan kinerja model.

Dengan menggunakan library scikit-learn kita dapat melakukan penskalaan feature dengan mudah.

from sklearn.preprocessing import StandardScaler
sc_X = StandardScaler()
X =  pd.DataFrame(sc_X.fit_transform(diabetes_data.drop(["Outcome"],axis = 1),),
        columns=['Pregnancies', 'Glucose', 'BloodPressure', 'SkinThickness', 'Insulin',
       'BMI', 'DiabetesPedigreeFunction', 'Age'])

Split Data Set

Tahap selanjutnya adalah membagi dataset menjadi subset pelatihan (training) dan pengujian (testing) dengan menggunakan library scikit-learn.

x = diabetes_data.drop('Outcome',axis=1)
y = diabetes_data['Outcome']

Dengan kode di atas, kita memisahkan anta feature dependen (x) dan independen (y) yang akan digunakan dalam proses data train dan data test nantinya.

from sklearn.model_selection import train_test_split
x_train, x_test, y_train,y_test=train_test_split(x,y,test_size=1/3,random_state=42,stratify=y)

dan pembagian data dilakukan sebagai berikut:

• x = adalah dataset fitur (data independen)
• y = adalah dataset target (label atau data dependen).
• Test_size = 1/3 mengatur bahwa 1/3 dari data akan menjadi data pengujian (testing), dan 2/3 sisanya akan menjadi data pelatihan (training).
• Random_state = 42 digunakan untuk mengatur “seed” dari generator angka acak. Ini memastikan bahwa pembagian data akan selalu konsisten jika Anda menjalankan kode ini beberapa kali. Anda dapat menggantinya dengan nilai lain jika Anda ingin hasil yang berbeda, atau menghilangkan parameter ini untuk hasil yang acak pada setiap eksekusi.
• Stratify = y digunakan untuk memastikan bahwa distribusi kelas target dalam subset pelatihan dan pengujian tetap seragam. Ini bermanfaat jika Anda memiliki masalah klasifikasi dan ingin memastikan bahwa setiap kelas hadir dalam proporsi yang benar dalam kedua subset.

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))

from sklearn.neighbors import KNeighborsClassifier

knn = KNeighborsClassifier(11)
knn.fit(x_train, y_train)
knn.score(x_test, y_test)

Dengan kode diatas, kita telah mealakukan data train dan data test yang akan digunakan dalam model KNN nantinya.

Membuat Model

Setelah data di-train dan di-test, maka siap dilakukan pembuatan model.

# Import necessary libraries
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
import matplotlib.pyplot as plt

output :

Kode di atas adalah untuk membuat model K-Nearest Neighbors (KNN) dengan menggunakan library scikit-learn. Di bawah ini adalah penjelasan dari setiap bagian kode:

• Import Libraries: Kode pertama mengimpor library yang dibutuhkan, yaitu train_test_split dari sklearn.model_selection, KNeighborsClassifier dari sklearn.neighbors, dan matplotlib.pyplot untuk visualisasi.
• Pemilihan Nilai k: Di sini, chosen_k ditetapkan sebagai 11. Ini adalah jumlah tetangga terdekat yang akan digunakan oleh model KNN. Nilai k harus dipilih sesuai dengan kebutuhan atau melalui teknik validasi seperti validasi silang.
• Inisialisasi Model KNN: Model KNN diinisialisasi dengan nilai k yang telah dipilih (11) menggunakan KNeighborsClassifier(chosen_k).
• Pelatihan Model: Model KNN difit ke data pelatihan (x_train dan y_train) menggunakan metode .fit(). Ini berarti model akan belajar untuk melakukan prediksi berdasarkan data pelatihan.
• Setelah model KNN telah difit, Anda dapat menggunakannya untuk melakukan prediksi dengan memanggil .predict() pada data uji.

Evaluasi Model

Kemudian perlu dilakukan tahap evaluasi model untuk mengetahui performa model sebelum digunakan untuk prediksi. Kita dapat menggunakan metode Confusion Matrix.

from sklearn.metrics import confusion_matrix

# Predict using the final trained model
y_pred = final_knn.predict(x_test)

# Generate confusion matrix
conf_matrix = confusion_matrix(y_test, y_pred)

# Print confusion matrix
print("Confusion Matrix:")
print(conf_matrix)

Confusion matrix adalah alat evaluasi yang sangat informatif untuk mengukur kinerja dari suatu model klasifikasi. Ini memberikan gambaran yang lebih rinci tentang bagaimana model mengklasifikasikan data, khususnya dalam konteks klasifikasi biner seperti kasus prediksi diabetes (0 atau 1).

Kode di atas digunakan untuk menghitung dan mencetak confusion matrix dari hasil prediksi yang dihasilkan oleh model K-Nearest Neighbors (KNN). Berikut penjelasan singkatnya:

• final_knn.predict(x_test): Pada baris pertama, model KNN (final_knn) digunakan untuk melakukan prediksi pada data pengujian (x_test) untuk memprediksi kelas hasil (0 atau 1) berdasarkan fitur yang diberikan.
• confusion_matrix(y_test, y_pred): Baris kedua digunakan untuk menghasilkan confusion matrix. Fungsi confusion_matrix dari modul sklearn.metrics digunakan untuk menghitung matriks ini. Anda perlu memberikan dua argumen: y_test adalah label sebenarnya dari data pengujian, dan y_pred adalah prediksi yang dihasilkan oleh model.
• print(“Confusion Matrix:”): Ini hanya mencetak judul “Confusion Matrix” agar jelas bahwa kita akan mencetak matriks.
• print(conf_matrix): Akhirnya, matriks dicetak ke layar. Matriks ini akan memiliki empat sel, yang mewakili:
  - True Positives (TP): Jumlah kasus positif yang diprediksi dengan benar.
  - False Positives (FP): Jumlah kasus negatif yang salah diprediksi sebagai positif.
  - False Negatives (FN): Jumlah kasus positif yang salah diprediksi sebagai negatif.
  - True Negatives (TN): Jumlah kasus negatif yang diprediksi dengan
  benar.

Kemudian kita dapat memanfaatkan Classification Report untuk mengetahui akurasi model.

from sklearn.metrics import classification_report

# Generate classification report
class_report = classification_report(y_test, y_pred)

# Print classification report
print("Classification Report:")
print(class_report)

Hasil dari model menunjukkan akurasi hingga 0.76.

Lantas apa yang harus dilakukan untuk meningkatkan akurasi?

Pada umumnya, kita dapat mengubah nilai k dengan Means Error terkecil. Namun kita dapat mencoba berbagai nilai k untuk mengetahui nilai k dengan akurasi tertinggi dengan kode berikut.

from sklearn.metrics import accuracy_score
accuracies = []
for k in range(1, 25):
    knn_model = KNeighborsClassifier(n_neighbors = k)
    knn_model.fit(x_train, y_train)
    y_pred_test = knn_model.predict(x_test)
    accuracy = accuracy_score(y_test, y_pred_test)
    accuracies.append(accuracy)
for k in range(1,25):
  print("k = ", k, " => Akurasi = ", np.round(accuracies[k-1], 2))
# Plot nilai akurasi
plt.plot(range(1,25), accuracies)
plt.ylabel('Akurasi')
plt.xlabel('k')

Dapat dilihat bahwa ketika K bernilai 7, akurasinya meningkat hingga 0.76. Kita dapat menggunakan nilai 7 untuk k sebagai nilai yang paling optimal.

chosen_k = 7
final_knn = KNeighborsClassifier(chosen_k)
final_knn.fit(x_train, y_train)

# Predict using the final trained model
y_pred = final_knn.predict(x_test)

# Generate confusion matrix
conf_matrix = confusion_matrix(y_test, y_pred)

# Print confusion matrix
print("Confusion Matrix:")
print(conf_matrix)

from sklearn.metrics import classification_report

# Generate classification report
class_report = classification_report(y_test, y_pred)

# Print classification report
print("Classification Report:")
print(class_report)

Bisa dilihat akurasi meningkat hingga 0.79.

Prediksi

Langkah selanjutnya, final model dapat digunakan untuk melakukan prediksi.

from sklearn.neighbors import KNeighborsClassifier

# Assuming you have already split the data into training and testing sets
knn = KNeighborsClassifier(n_neighbors=11)
knn.fit(x_train, y_train)

new_data = pd.read_csv('/content/drive/MyDrive/AMCC/diabetes.csv')
clean_data = new_data.drop('Outcome', axis=1)
predicted_outcome = knn.predict(clean_data)

# Print the Predicted Outcome
print("Predicted Outcome:")
print(predicted_outcome)

Code di atas melakukan beberapa hal:

• from sklearn.neighbors import KNeighborsClassifier: Ini mengimpor kelas KNeighborsClassifier dari pustaka sklearn.neighbors. Kelas ini digunakan untuk membuat dan melatih model K-Nearest Neighbors.
• knn = KNeighborsClassifier(n_neighbors=11): Membuat objek knn yang merupakan instance dari model K-Nearest Neighbors. n_neighbors=11 mengatur jumlah tetangga terdekat yang akan digunakan oleh model untuk membuat prediksi.
• knn.fit(x_train, y_train): Melatih model KNN dengan menggunakan data latih x_train dan labelnya y_train.
• new_data = pd.read_csv(‘/content/drive/MyDrive/AMCC/diabetes.csv’): Memuat data baru dari file CSV.
• clean_data = new_data.drop(‘Outcome’, axis=1): Menghapus kolom ‘Outcome’ dari data untuk mempersiapkannya agar dapat digunakan untuk prediksi.
• predicted_outcome = knn.predict(clean_data): Menggunakan model KNN yang telah dilatih untuk memprediksi kolom ‘Outcome’ dari data clean_data.
• print(“Predicted Outcome:”): Ini hanya mencetak judul “Predicted Outcome” untuk memberikan konteks pada hasil prediksi.print(predicted_outcome): Ini mencetak hasil prediksi dari kolom ‘Outcome’. Hasilnya adalah serangkaian nilai 0 dan 1, yang merupakan prediksi model untuk setiap baris dalam data clean_data.

written by Dianprasetya and Jhingga