Decision Trees dalam Machine Learning dan Kecerdasan Buatan

 Definisi Decision Trees

Decision Trees adalah model prediktif yang digunakan dalam machine learning untuk membuat keputusan berdasarkan serangkaian aturan yang dihasilkan dari data. Mereka bekerja dengan membagi dataset ke dalam subset yang lebih kecil dan lebih homogen, mendasarkan pemisahan pada fitur yang paling informatif. Decision Trees sering digunakan untuk tugas klasifikasi dan regresi.

Komponen-Komponen Kunci dan Struktur Decision Trees

1. Root Node: Node pertama dari pohon yang mewakili seluruh dataset. Pemisahan pertama berdasarkan fitur yang paling informatif terjadi di sini.
2. Internal Nodes: Node dalam pohon yang mewakili fitur pada dataset dan mengandung aturan keputusan yang memisahkan data.
3. Leaf Nodes: Node terminal yang memberikan keputusan akhir atau prediksi. Setiap leaf node merepresentasikan satu kelas atau nilai output.
4. Decision Rules: Aturan yang digunakan untuk memisahkan dataset pada setiap node. Aturan ini didasarkan pada nilai fitur yang memaksimalkan pemisahan kelas atau meminimalkan kesalahan.

Cara Kerja Algoritma Decision Tree

1. Pemilihan Fitur: Pilih fitur yang paling informatif untuk memisahkan data. Kriteria umum termasuk Gini Impurity, Information Gain (Entropy), atau Mean Squared Error (untuk regresi).
2. Pemisahan Data: Pisahkan dataset berdasarkan fitur yang dipilih, menciptakan node baru untuk setiap subset data.
3. Rekursi: Terapkan langkah 1 dan 2 secara rekursif pada setiap subset data.
4. Terminal Condition: Rekursi berakhir ketika node mencapai kriteria tertentu, seperti kedalaman maksimum pohon atau jumlah minimum sampel per node. Node terminal menjadi leaf nodes yang memberikan prediksi.

Langkah-Langkah Algoritma Decision Tree

1. Pembentukan Tree:

   • Pilih fitur terbaik yang memisahkan dataset paling efektif. Ini sering dilakukan menggunakan metrik seperti Gini Impurity atau Information Gain.
   • Buat decision node berdasarkan fitur yang dipilih dan bagi dataset ke dalam subset.
   • Ulangi proses ini secara rekursif untuk setiap subset sampai salah satu kondisi penghentian terpenuhi (misalnya, semua data dalam satu subset memiliki label yang sama atau jumlah data dalam subset terlalu kecil).

2. Membuat Prediksi:

   • Mulai dari root node dan evaluasi fitur berdasarkan decision rules.
   • Ikuti cabang berdasarkan hasil evaluasi sampai mencapai leaf node.
   • Leaf node memberikan prediksi.

3. Evaluasi Kinerja Model:

• Gunakan metrik seperti akurasi, precision, recall, F1-score untuk klasifikasi, dan Mean Squared Error (MSE) untuk regresi.
• Validasi model dengan metode seperti k-fold cross-validation untuk mendapatkan estimasi kinerja yang lebih andal.

Implementasi Decision Trees dalam Python

Contoh 1.1: Klasifikasi dengan Decision Trees

python 
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score, classification_report
import matplotlib.pyplot as plt
from sklearn import tree

# Load dataset
data = pd.read_csv('data/iris.csv')  # Misalnya dataset Iris

# Split dataset
X = data.drop(columns=['species'])
y = data['species']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Create and train the model
clf = DecisionTreeClassifier()
clf.fit(X_train, y_train)

# Make predictions
y_pred = clf.predict(X_test)

# Evaluate the model
accuracy = accuracy_score(y_test, y_pred)
print(f'Accuracy: {accuracy}')
print(classification_report(y_test, y_pred))

# Visualize the tree
plt.figure(figsize=(20,10))
tree.plot_tree(clf, filled=True, feature_names=X.columns, class_names=clf.classes_, rounded=True)
plt.show()

Contoh 1.2: Klasifikasi Dataset Iris

python

# Import library yang dibutuhkan
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
from sklearn.tree import export_text

# Memuat dataset
iris = load_iris()
X = iris.data
y = iris.target

# Membagi dataset menjadi training dan testing
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Membuat dan melatih model Decision Tree
clf = DecisionTreeClassifier(random_state=42)
clf.fit(X_train, y_train)

# Membuat prediksi
y_pred = clf.predict(X_test)

# Mengevaluasi kinerja model
accuracy = accuracy_score(y_test, y_pred)
print(f'Akurasi: {accuracy:.2f}')

# Menampilkan struktur tree
tree_rules = export_text(clf, feature_names=iris.feature_names)
print(tree_rules)

Contoh 1.3: Klasifikasi Iris
python
from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Load dataset
iris = load_iris()
X, y = iris.data, iris.target

# Split data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Create and train model
clf = DecisionTreeClassifier(random_state=42)
clf.fit(X_train, y_train)

# Make predictions
y_pred = clf.predict(X_test)

# Evaluate model
accuracy = accuracy_score(y_test, y_pred)
print(f"Akurasi: {accuracy:.2f}")

# Visualisasi tree (opsional)
from sklearn.tree import plot_tree
import matplotlib.pyplot as plt

plt.figure(figsize=(20,10))
plot_tree(clf, feature_names=iris.feature_names, class_names=iris.target_names, filled=True)
plt.show()
Interpretasi: Model ini mengklasifikasikan bunga Iris berdasarkan karakteristik fisiknya. 
Akurasi yang tinggi menunjukkan bahwa Decision Tree berhasil mempelajari 
pola dalam data untuk membedakan jenis-jenis Iris.

Contoh 2.1: Regresi dengan Decision Trees

python 
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeRegressor
from sklearn.metrics import mean_squared_error
import matplotlib.pyplot as plt

# Generate synthetic data
X = np.random.rand(100, 1) * 10
y = 2 * X.squeeze() ** 2 + 3 * X.squeeze() + np.random.randn(100) * 2

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

# Create and train the model
regressor = DecisionTreeRegressor()
regressor.fit(X_train, y_train)

# Make predictions
y_pred = regressor.predict(X_test)

# Evaluate the model
mse = mean_squared_error(y_test, y_pred)
print(f'Mean Squared Error: {mse}')

# Visualize the results
plt.scatter(X_test, y_test, color='red', label='Actual')
plt.scatter(X_test, y_pred, color='blue', label='Predicted')
plt.title('Decision Tree Regression')
plt.xlabel('Feature')
plt.ylabel('Target')
plt.legend()
plt.show()

Contoh 2: Regresi Dataset Boston Housing
python
--------------------------------------------------------------------------------------------------------------
# Import library yang dibutuhkan
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeRegressor
from sklearn.metrics import mean_squared_error

# Memuat dataset
boston = load_boston()
X = boston.data
y = boston.target

# Membagi dataset menjadi training dan testing
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Membuat dan melatih model Decision Tree
reg = DecisionTreeRegressor(random_state=42)
reg.fit(X_train, y_train)

# Membuat prediksi
y_pred = reg.predict(X_test)

# Mengevaluasi kinerja model
mse = mean_squared_error(y_test, y_pred)
print(f'Mean Squared Error: {mse:.2f}')
--------------------------------------------------------------------------------------------------------------
Contoh 2: Prediksi Harga Rumah
python
from sklearn.datasets import fetch_california_housing
from sklearn.tree import DecisionTreeRegressor
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
import numpy as np

# Load dataset
housing = fetch_california_housing()
X, y = housing.data, housing.target

# Split data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Create and train model
regressor = DecisionTreeRegressor(random_state=42)
regressor.fit(X_train, y_train)

# Make predictions
y_pred = regressor.predict(X_test)

# Evaluate model
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
print(f"Root Mean Squared Error: {rmse:.2f}")

# Feature importance
for name, importance in zip(housing.feature_names, regressor.feature_importances_):
    print(f"{name}: {importance:.4f}")
Interpretasi : model ini memprediksi harga rumah berdasarkan harga fitur. RMSE memberikan indikasi seberapa jauh prediksi dari nilai sebenarnnya. fitur important menunjukkan fitur yang paling berpengaruh dalam prediksi harga rumah.

Keuntungan dan Keterbatasan Decision Trees
Keuntungan
Mudah Dipahami dan Diinterpretasikan: Struktur pohon dapat divisualisasikan dan mudah dimengerti oleh manusia.
Sedikit Prasyarat pada Data: Tidak memerlukan normalisasi data atau scaling fitur.
Bekerja dengan Data Kategori dan Numerik: Dapat menangani berbagai jenis data tanpa perlu pra-pemrosesan yang rumit.
Keterbatasan
Overfitting: Decision Trees cenderung overfitting pada data pelatihan, terutama jika pohon terlalu dalam.
Tidak Stabil: Perubahan kecil dalam data dapat menghasilkan pohon yang sangat berbeda.
Tidak Efisien untuk Data Besar: Pohon yang sangat dalam dapat menjadi tidak efisien dan lambat untuk data besar.
Kapan Menggunakan Decision Trees
Interpretabilitas Penting: Ketika interpretasi model sangat penting, seperti dalam aplikasi medis atau hukum.
Data Heterogen: Ketika dataset terdiri dari berbagai jenis fitur (numerik dan kategori).
Cepat Membuat Prototipe: Untuk eksplorasi cepat dan pemahaman tentang fitur yang paling informatif dalam data.
Alternatif Lain
Random Forests: Mengatasi overfitting dengan menggabungkan banyak pohon keputusan.
Gradient Boosting: Menggabungkan beberapa model sederhana secara iteratif untuk meningkatkan akurasi.
Support Vector Machines (SVM): Baik untuk klasifikasi dengan margin yang jelas antara kelas.
Dengan memahami dan mengimplementasikan Decision Trees, kita dapat memanfaatkan model ini untuk berbagai tugas machine learning dan kecerdasan buatan, baik dalam klasifikasi maupun regresi, dengan mempertimbangkan keuntungan dan keterbatasannya. Decision Trees adalah alat yang kuat dalam pembelajaran mesin, namun penting untuk mengetahui kapan dan bagaimana mereka digunakan untuk mendapatkan hasil yang optimal.