Decision Tree (pohon keputusan) merupakan salah satu algoritma machine learning yang paling intuitif dan mudah dipahami. Berbeda dengan banyak algoritma lain yang bekerja seperti “kotak hitam”, Decision Tree justru menampilkan proses pengambilan keputusan secara eksplisit dalam bentuk struktur yang menyerupai diagram alur. Setiap cabang merepresentasikan sebuah pertanyaan terhadap fitur data, dan setiap daun merepresentasikan hasil akhir atau prediksi tertentu.

Kekuatan utama Decision Tree terletak pada kemampuannya menangani dua jenis permasalahan sekaligus: klasifikasi (menentukan kategori, misalnya “apakah pelanggan akan berhenti berlangganan?”) dan regresi (memprediksi nilai kontinu, misalnya “berapa harga rumah?”). Algoritma ini juga tidak menuntut banyak pra-pemrosesan data seperti normalisasi atau encoding yang rumit, sehingga sangat cocok sebagai gerbang pertama bagi siapa pun yang baru memulai belajar machine learning.

Di artikel ini, kita akan membahas konsep inti di balik Decision Tree, bagaimana algoritma memilih fitur untuk memecah data, lalu langsung menerapkannya dengan Python menggunakan pustaka scikit-learn. Kita akan mempraktikkan klasifikasi pada dataset bunga Iris yang terkenal, sekaligus memahami cara membaca dan mengevaluasi hasilnya.

Cara Kerja Decision Tree

Sebuah Decision Tree dibangun dengan cara membagi data secara rekursif menjadi bagian-bagian yang semakin kecil dan semakin “murni”. Bayangkan kita memiliki sekumpulan data dan ingin memisahkan kelas-kelas di dalamnya. Algoritma akan mencari fitur serta nilai ambang tertentu yang paling efektif dalam memisahkan satu kelas dari kelas lainnya, kemudian menjadikannya sebagai pertanyaan pertama di akar pohon.

Proses ini diulang pada setiap cabang yang terbentuk hingga memenuhi kriteria berhenti, misalnya ketika semua data di suatu simpul sudah berasal dari kelas yang sama, atau ketika kedalaman pohon mencapai batas yang ditentukan. Hasil akhirnya adalah hierarki pertanyaan yang, jika ditelusuri dari akar hingga daun, akan memberikan prediksi untuk data baru.

Dua konsep penting yang digunakan untuk memilih pembagian terbaik adalah Gini Impurity dan Information Gain (berbasis entropi). Gini Impurity mengukur seberapa sering sebuah elemen yang dipilih secara acak akan salah diklasifikasikan, sementara Information Gain mengukur seberapa banyak ketidakpastian yang berkurang setelah data dipecah. Secara sederhana, algoritma akan memilih pemisahan yang paling besar menurunkan “kekotoran” atau ketidakpastian tersebut.

Kelebihan dan Keterbatasan

Decision Tree menawarkan sejumlah keunggulan yang membuatnya populer. Pertama, hasilnya sangat mudah diinterpretasikan dan divisualisasikan, sehingga cocok untuk dijelaskan kepada pihak non-teknis. Kedua, algoritma ini mampu menangani data numerik maupun kategorikal tanpa perlu transformasi yang rumit. Ketiga, karena tidak bergantung pada skala fitur tertentu, Decision Tree relatif tahan terhadap outlier dalam beberapa kasus.

Namun, Decision Tree juga memiliki keterbatasan yang perlu diwaspadai. Algoritma ini cenderung mengalami overfitting, yaitu terlalu “menghafal” pola di data latih sehingga gagal menggeneralisasi data baru. Decision Tree juga sangat sensitif terhadap perubahan kecil pada data, di mana sedikit perbedaan dapat mengubah struktur pohon secara drastis. Keterbatasan-keterbatasan inilah yang kemudian melahirkan teknik ensemble seperti Random Forest dan Gradient Boosting yang menggabungkan banyak pohon untuk hasil yang lebih stabil.

Mempersiapkan Lingkungan dan Data

Sebelum menulis kode, pastikan pustaka yang dibutuhkan telah terpasang. Kita akan menggunakan scikit-learn, pandas, dan matplotlib untuk pemodelan serta visualisasi.

# Instalasi pustaka yang diperlukan (jalankan di terminal)
# pip install scikit-learn pandas matplotlib

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

Dataset Iris yang akan kita gunakan berisi 150 sampel bunga yang terbagi ke dalam tiga spesies: setosa, versicolor, dan virginica. Setiap sampel memiliki empat fitur pengukuran, yaitu panjang kelopak (sepal length), lebar kelopak (sepal width), panjang mahkota (petal length), dan lebar mahkota (petal width).

iris = load_iris()
X = iris.data
y = iris.target

df = pd.DataFrame(X, columns=iris.feature_names)
df['target'] = y
print(df.head())
print(df['target'].value_counts())

Dari output di atas, kita akan melihat bahwa setiap kelas memiliki 50 sampel, sehingga dataset berada dalam kondisi seimbang. Ini memudahkan kita dalam menginterpretasikan akurasi model.

Pelatihan Model

Langkah berikutnya adalah membagi data menjadi data latih dan data uji. Pembagian 80:20 adalah pilihan yang umum, di mana 80% data digunakan untuk melatih model dan 20% sisanya untuk menguji performa model pada data yang belum pernah dilihat sebelumnya.

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

model = DecisionTreeClassifier(random_state=42)
model.fit(X_train, y_train)

y_pred = model.predict(X_test)
print(f"Akurasi: {accuracy_score(y_test, y_pred):.2f}")

Dengan ukuran dataset yang sederhana ini, akurasi model biasanya berada di kisaran yang tinggi. Namun, angka akurasi saja tidak cukup untuk memahami kualitas model. Kita perlu melihat laporan klasifikasi yang memuat precision, recall, dan f1-score untuk setiap kelas.

print(classification_report(y_test, y_pred, target_names=iris.target_names))

Laporan tersebut menunjukkan seberapa baik model mengenali setiap spesies. Pada dataset Iris yang relatif mudah dipisahkan, model umumnya mencapai f1-score mendekati 1.0 untuk sebagian besar kelas.

Memahami Struktur Pohon

Salah satu daya tarik terbesar Decision Tree adalah kemampuannya untuk divisualisasikan. Dengan fungsi plot_tree, kita dapat melihat pertanyaan apa yang diajukan pada setiap simpul beserta nilai ambang batasnya.

plt.figure(figsize=(16, 10))
plot_tree(
    model,
    feature_names=iris.feature_names,
    class_names=iris.target_names,
    filled=True,
    rounded=True
)
plt.show()

Pada visualisasi tersebut, setiap simpul menampilkan kondisi pembagian, nilai Gini Impurity, jumlah sampel yang masuk, serta distribusi kelas. Warna yang berbeda menandakan dominasi kelas tertentu. Dari sini kita dapat menyimpulkan bahwa fitur petal length dan petal width sering kali menjadi pemisah yang paling informatif untuk membedakan spesies Iris.

Menyesuaikan Hyperparameter untuk Menghindari Overfitting

Decision Tree secara bawaan dapat tumbuh sangat dalam hingga setiap daun berisi satu sampel, yang berisiko menyebabkan overfitting. Untuk mengendalikannya, scikit-learn menyediakan sejumlah hyperparameter penting, antara lain:

• max_depth: membatasi kedalaman maksimum pohon.
• min_samples_split: jumlah sampel minimum yang diperlukan untuk memecah sebuah simpul.
• min_samples_leaf: jumlah sampel minimum yang harus ada di setiap daun.
• max_features: jumlah fitur yang dipertimbangkan saat mencari pemisahan terbaik.

Kita dapat membatasi kedalaman pohon untuk membuat model lebih sederhana dan lebih mudah digeneralisasi.

model_pruned = DecisionTreeClassifier(
    max_depth=3,
    min_samples_split=5,
    min_samples_leaf=2,
    random_state=42
)
model_pruned.fit(X_train, y_train)

y_pred_pruned = model_pruned.predict(X_test)
print(f"Akurasi (pruned): {accuracy_score(y_test, y_pred_pruned):.2f}")

Dengan pembatasan ini, struktur pohon menjadi lebih ringkas tanpa mengorbankan banyak akurasi. Dalam praktiknya, menemukan kombinasi hyperparameter terbaik dapat dilakukan melalui teknik seperti Grid Search atau Randomized Search dengan validasi silang (cross-validation).

Mengukur Pentingnya Fitur

Decision Tree juga dapat memberikan informasi mengenai fitur mana yang paling berpengaruh dalam pengambilan keputusan. Atribut feature_importances_ memberikan bobot untuk setiap fitur berdasarkan seberapa besar kontribusinya dalam mengurangi impuritas.

importances = model.feature_importances_
feature_importance_df = pd.DataFrame({
    'fitur': iris.feature_names,
    'importance': importances
}).sort_values('importance', ascending=False)

print(feature_importance_df)

plt.barh(feature_importance_df['fitur'], feature_importance_df['importance'])
plt.xlabel('Feature Importance')
plt.title('Tingkat Kepentingan Fitur')
plt.show()

Hasilnya biasanya menunjukkan bahwa petal length dan petal width memiliki tingkat kepentingan tertinggi, sejalan dengan pengamatan pada visualisasi pohon sebelumnya. Analisis semacam ini sangat berguna untuk penyederhanaan model atau pemilihan fitur (feature selection).

Kesimpulan

Decision Tree adalah algoritma yang kuat sekaligus mudah dipahami untuk permasalahan klasifikasi maupun regresi. Melalui Python dan scikit-learn, kita dapat membangun model hanya dalam beberapa baris kode, memvisualisasikan struktur pengambilan keputusannya, serta mengevaluasi dan menyempurnakan performanya.

Meskipun rentan terhadap overfitting dan ketidakstabilan, keterbatasan tersebut dapat dikelola melalui penyetelan hyperparameter. Lebih jauh lagi, memahami Decision Tree menjadi fondasi penting untuk menguasai algoritma ensemble yang lebih canggih seperti Random Forest dan Gradient Boosting, yang kini menjadi tulang punggung banyak solusi machine learning di dunia nyata. Dengan pemahaman konsep dan praktik yang telah diuraikan, Anda kini siap melangkah ke tahap berikutnya dalam perjalanan belajar machine learning.