Pada artikel sebelumnya, kita sudah belajar tentang decision tree untuk kasus regresi. Pada artikel ini, kita akan lanjut mempelajari Decision Tree Classifier, yang mana penggunaannya adalah untuk mengelompokkan data ke dalam kategori-kategori berbeda. Decision Tree di sini bekerja secara rekursif dengan cara memisahkan data berdasarkan fitur yang paling signifikan, hingga nantinya mencapai keputusan yang akhir.

Decision Tree Proses

Sama seperti untuk regresi, sebuah Decision Tree terdiri dari tiga jenis node:

Root Node: Node pertama yang memulai pembagian.
Internal Node: Node di dalam pohon yang memisahkan data berdasarkan fitur tertentu.
Leaf Node: Node terakhir yang memberikan prediksi kelas.

Pada proses membuat Decision Tree untuk klasifikasi, terdapat sejumlah langkah penting:

Pemilihan Fitur: Memilih fitur yang paling signifikan untuk memisahkan data pada setiap langkah.
Kriteria Pembagian: Menentukan bagaimana memisahkan data di setiap simpul.
Pembentukan Simpul: Mengulangi proses pemisahan hingga kriteria penghentian terpenuhi (misalnya, kedalaman maksimum pohon atau jumlah minimum sampel dalam simpul).

Salah satu aspek paling penting dari Decision Tree Classifier adalah memilih cara terbaik untuk memisahkan data di setiap simpul. Untuk klasifikasi, biasanya digunakan kriteria seperti Gini Impurity atau Entropy (Information Gain).

Rumus Gini Impurity:

\(\text{Gini} = 1 - \sum_{i=1}^{C} p_i^2\)

Rumus Entropy:

\(\text{Entropy} = - \sum_{i=1}^{C} p_i \log(p_i)\)

dimana:

\(C\) adalah jumlah kelas.
\(p_i\)adalah proporsi sampel yang termasuk dalam kelas \(i\).

Algoritma akan mencari pembagian yang meminimalkan Gini Impurity atau Entropy pada setiap simpul.

Selanjutnya proses pemilihan fitur melibatkan perhitungan Gini Impurity atau Entropy untuk setiap fitur dan titik pembagian yang mungkin. Misalnya, jika kita memiliki fitur X dengan nilai-nilai \([1, 2, 3, 4, 5]\) dan kelas Y dengan nilai-nilai \([0, 1, 0, 1, 0]\), kita dapat mencoba berbagai titik pembagian seperti \(X < 2.5\), \(X < 3.5\), dll., dan menghitung Gini Impurity atau Entropy untuk setiap pembagian. Pembagian dengan nilai terendah akan dipilih.

Kelebihan dari decision tree adalah mudah diinterpretasikan dan divisualisasikan. Decision tree juga dapat menangani hubungan non-linear antara fitur dan kelas. Selain itu, Algoritma juga akan secara otomatis memilih fitur yang paling signifikan.

Kekurangan:

Overfitting: Pohon keputusan cenderung overfitting pada data training, terutama jika tidak diatur kedalamannya.
Stabilitas: Pohon keputusan sensitif terhadap perubahan kecil dalam data; perubahan kecil dapat menghasilkan struktur pohon yang sangat berbeda.

Studi Kasus: Prediksi Penyakit Jantung

Untuk contoh penggunaan decision tree classifier, kita akan menggunakan dataset Heart Disease dari Kaggle.

Import Libraries

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import confusion_matrix, classification_report, accuracy_score

pandas dan numpy digunakan untuk manipulasi data.
matplotlib dan seaborn digunakan untuk visualisasi.
train_test_split digunakan untuk membagi data menjadi set pelatihan dan pengujian.
DecisionTreeClassifier digunakan untuk membuat model klasifikasi pohon keputusan.
confusion_matrix, classification_report, dan accuracy_score digunakan untuk evaluasi performa model.

Load Dataset

df = pd.read_csv('/kaggle/input/heart-failure-clinical-data/heart_failure_clinical_records_dataset.csv')

Membaca data dari file CSV yang berisi informasi tentang pasien dengan penyakit jantung dan fitur-fitur yang terkait.

df.head()

Di sini kita melihat lima data teratas dari dataset. Dengan melakukan visualisasi seperti ini kita bisa mendapatkan gambaran tentang bagaimana kondisi data-data dan kolom-kolom fitur yang tersedia.

Descriptive Statistics

df.describe()

Setelah melihat ini contoh data-data teratas kita kemudian bisa menampilkan statistik deskriptif seperti mean, std, min, max untuk setiap kolom dalam dataset.

Informasi Data

df.info()

Memberikan informasi tentang tipe data dan jumlah nilai null untuk setiap kolom. Mengetahui tipe data dan jumlah null perlu diperlakukan agar bisa menjadi pertimbangan ketika melakukan preprocessing nanti.

Visualisasi Distribusi Target

plt.figure(figsize=(10, 6))
sns.countplot(x='DEATH_EVENT', data=df)
plt.title('Target Variable Distribution')
plt.show()

Dari visualisasi yang kita lakukan didapatkan bahwa target dengan label 0 memiliki jumlah data yang lebih banyak dari label 1. Sehingga bisa dikatakan bahwa data kita saat ini imbalanced.

Visualisasi Korelasi Fitur

plt.figure(figsize=(12, 8))
sns.heatmap(df.corr(), annot=True, fmt='.2f', cmap='coolwarm')
plt.title('Correlation Heatmap')
plt.show()

Heatmap di atas menunjukkan data-data yang memiliki korelasi dengan kolom DEATH_EVENT sebagai target. Nilai positif menunjukkan korelasi positif antar data, sebagai contoh semakin tinggi nilai pada kolom time maka cenderung juga kemungkinan DEATH_EVENT semakin tinggi. Sebaliknya pada data-data yang memiliki korelasi negatif.

Preprocessing Data

Normalisasi Fitur Numerik

from sklearn.preprocessing import StandardScaler

# Normalize numerical features
scaler = StandardScaler()
numerical_features = ['age', 'creatinine_phosphokinase', 'ejection_fraction', 'platelets', 'serum_creatinine', 'serum_sodium', 'time']
df[numerical_features] = scaler.fit_transform(df[numerical_features])

Di sini kita akan menggunakan Standard Scaler sebagai teknik prapemrosesan data. Teknik ini digunakan untuk menstandarisasi fitur-fitur numerik dalam dataset sehingga memiliki rata-rata (mean) nol dan standar deviasi satu. Proses ini membantu algoritma agar bisa bekerja dengan lebih efisien dengan mempercepat konvergensi dan mengurangi bias dalam fitur yang memiliki skala berbeda.

Pemilihan Fitur dan Target

X = df.drop(columns=['DEATH_EVENT'])
y = df['DEATH_EVENT']

Setelah dilakukan standarisasi, kita bisa kemudian menentukan kolom-kolom yang menjadi variabel fitur dan target. Di sini kita menggunakan DEATH_EVENT sebagai target dan kolom selainnya sebagai fitur.

Pemisahan Data

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

Kemudian kita membagi data menjadi data train dan data text. Kita menggunakan ukuran split di sini 80% untuk training dan 20% untuk testing.

Hyperparameter Tuning

Menggunakan GridSearchCV untuk menemukan kombinasi hyperparameter terbaik.

from sklearn.model_selection import GridSearchCV

# Initialize Decision Tree model
model = DecisionTreeClassifier(random_state=42)

# Define parameter grid
param_grid = {
    'criterion': ['gini', 'entropy'],
    'max_depth': [None, 10, 20, 30],
    'min_samples_split': [2, 10, 20],
    'min_samples_leaf': [1, 5, 10]
}

# Initialize GridSearchCV
grid_search = GridSearchCV(estimator=model, param_grid=param_grid, cv=5, n_jobs=-1, scoring='accuracy')
grid_search.fit(X_train, y_train)

# Best parameters and model
best_params = grid_search.best_params_
best_model = grid_search.best_estimator_

print(f'Best Parameters: {best_params}')

Selain pada model, pengembangan machine learning juga sangat bergantung pada parameter-parameter yang digunakan untuk melatih model. Di sini kita melakukan grid search untuk melihat kombinasi dari setiap parameter yang ada.

Train and Evaluate the Best Model

# Train the best model
best_model.fit(X_train, y_train)

# Predictions
y_pred_train = best_model.predict(X_train)
y_pred_test = best_model.predict(X_test)

# Evaluation metrics
conf_matrix = confusion_matrix(y_test, y_pred_test)
class_report = classification_report(y_test, y_pred_test)
accuracy = accuracy_score(y_test, y_pred_test)

print(f'Confusion Matrix:\n{conf_matrix}')
print(f'Classification Report:\n{class_report}')
print(f'Accuracy: {accuracy}')

Setelah kita mendapatkan model dengan parameter terbaik. Kita melakukan training pada data latih kemudian mengujinya pada data tes. Terakhir kita melakukan evaluasi dengan melihat classification report dari model.

Visualisasi Decision Tree

from sklearn.tree import plot_tree

plt.figure(figsize=(20, 10))
plot_tree(best_model, filled=True, feature_names=X.columns, class_names=['No Disease', 'Disease'], max_depth=2, fontsize=10)
plt.show()

Sebagaimana telah disinggung. Kelebihan dari decision tree adalah sifatnya yang mudah diinterpretasi. Di sini kita melakukan visualisasi dengan kedalaman 2.

Visualisasi Confusion Matrix

plt.figure(figsize=(8, 6))
sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', xticklabels=['No Disease', 'Disease'], yticklabels=['No Disease', 'Disease'])
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix')
plt.show()

Dari visualisasi di atas, kita dapat melihat hasil prediksi model yang didapatkan. Dari sini juga kita bisa menganalisa bagian-bagian mana yang diprediksi dengan baik oleh model dan bagian yang mana yang tidak. Sehingga berguna untuk analisa lebih lanjut di masa depan.

Kesimpulan

Dalam artikel ini, kita telah membahas bagaimana Decision Tree Classifier bekerja, mulai dari pemilihan fitur, kriteria pembagian, hingga pembentukan simpul. Kita juga telah melakukan studi kasus prediksi penyakit jantung. Model Decision Tree Classifier menawarkan interpretabilitas yang tinggi, memudahkan kita untuk memahami dan menjelaskan prediksi yang dihasilkan. Namun, penting untuk diingat bahwa model ini bisa sangat sensitif terhadap perubahan kecil dalam data dan cenderung overfitting jika tidak diatur dengan benar.

Dengan pemahaman yang mendalam tentang bagaimana Decision Tree Classifier bekerja dan bagaimana mengimplementasikannya, kita sekarang siap untuk menerapkan algoritma ini pada berbagai masalah klasifikasi lainnya. Terima kasih sudah membaca artikel ini, Selamat Belajar!

Source Code : Kaggle

Prediksi Penyakit Jantung dengan Decision Tree Classifier