Decision Tree

Compiled by: Suprapto van Plaosan

Pengertian

Decision tree merupakan metode non parametrik yang digunakan untuk klasifikasi dan regresi. Tujuan dari decision tree adalah membuat model yang memprediksi nilai variabel target dengan mengikuti aturan keputusan sederhana dari fitur data yang tersedia

Algoritma Decision Tree

  • Decision Tree adalah jenis white box algoritma dalam machine learning yang menggunakan internal decision making logic. Hal ini tidak terdapat dapat pada jenis black box algoritma yaitu neural network. Waktu pengambilan data training decision tree lebih cepat dibandingkan Neural Network.
  • Fungsi Kompleksitas Decision Tree adalah fungsi dari jumlah yang records serta atribut dalam data yang diberikan.

Kerja Algoritma Decision Tree

  • memilih atribut terbaik menggunakan Attribution Selection Measures (ASM) untuk membagi records data
  • membuat atribut menjadi decision node dan memecah dataset menjadi subsets yang lebih kecil.
  • Mulai membangun pohon dengan mengulangi proses ini secara rekursif, untuk setiap cabang sampai salah satu dari kondisi tersebut akan cocok

image.png

Attribute Selection Measures

  • Attribute selection measure is a heuristik dalam pemilihan kriteria splitting bagian-bagian data menjadi aturan yang sesuai. Hal ini juga menjadikan acuan splitting karena membantu kita untuk mengetahui breakpoint pada tuples yang diberikan oleh node. ASM memberikan tingkatan pada setiap fitur dengan menjelaskan dataset yang diberikan. Nilai terbaik dari fitur akan dipilih sebagai fitur splitting. Contoh attribute selection measures adalah Informasi Gain, Rasio Gain, Indeks Gini.

Kelebihan Decision Tree

  • Mudah dipahami dan diintrepetasikan
  • Membutuhkan sedikit persiapan data. Teknik lain sering membutuhkan normalisasi data, variabel dummy perlu dibuat dan nilai- nilai kosong harus dihapus. Namun perlu dicatat bahwa modul ini tidak mendukung nilai yang hilang
  • Dapat digunakan untuk validasi model menggunakan tes statistik. Itu memungkinkan untuk memperhitungkan keandalan model.
  • Mampu menyelesaikan masalah multi-output.

Kekurangan Decision Tree

  • Learner Decision Tree dapat membuat bagan terlalu rumit yang tidak menggeneralisasikan data dengan baik. Ini disebut overfitting. Mekanisme seperti pemangkasan (saat ini tidak didukung), pengaturan jumlah sampel minimum yang diperlukan pada simpul daun atau pengaturan kedalaman maksimum pohon diperlukan untuk menghindari masalah ini.
  • Decision tree menjadi tidak stabil karena variasi kecil dalam data yang menghasilkan pohon yang berbeda. Solusi masalah ini dengan menggunakan Decision tree dalam sebuah ensemble.
  • Learner Decision tree keputusan membuat pohon bias jika beberapa kelas mendominasi. Oleh karena itu disarankan untuk menyeimbangkan dataset sebelum disesuaikan dengan pohon keputusan

Solusi untuk beberapa kelas yang mendominasi

In [1]:
import pandas as pd
from sklearn.datasets import load_breast_cancer
bc=load_breast_cancer()
df= pd.DataFrame(bc.data, columns=bc.feature_names)
df['diagnosis']=bc.target
df
Out[1]:
mean radius mean texture mean perimeter mean area mean smoothness mean compactness mean concavity mean concave points mean symmetry mean fractal dimension ... worst texture worst perimeter worst area worst smoothness worst compactness worst concavity worst concave points worst symmetry worst fractal dimension diagnosis
0 17.99 10.38 122.80 1001.0 0.11840 0.27760 0.30010 0.14710 0.2419 0.07871 ... 17.33 184.60 2019.0 0.16220 0.66560 0.7119 0.2654 0.4601 0.11890 0
1 20.57 17.77 132.90 1326.0 0.08474 0.07864 0.08690 0.07017 0.1812 0.05667 ... 23.41 158.80 1956.0 0.12380 0.18660 0.2416 0.1860 0.2750 0.08902 0
2 19.69 21.25 130.00 1203.0 0.10960 0.15990 0.19740 0.12790 0.2069 0.05999 ... 25.53 152.50 1709.0 0.14440 0.42450 0.4504 0.2430 0.3613 0.08758 0
3 11.42 20.38 77.58 386.1 0.14250 0.28390 0.24140 0.10520 0.2597 0.09744 ... 26.50 98.87 567.7 0.20980 0.86630 0.6869 0.2575 0.6638 0.17300 0
4 20.29 14.34 135.10 1297.0 0.10030 0.13280 0.19800 0.10430 0.1809 0.05883 ... 16.67 152.20 1575.0 0.13740 0.20500 0.4000 0.1625 0.2364 0.07678 0
... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ...
564 21.56 22.39 142.00 1479.0 0.11100 0.11590 0.24390 0.13890 0.1726 0.05623 ... 26.40 166.10 2027.0 0.14100 0.21130 0.4107 0.2216 0.2060 0.07115 0
565 20.13 28.25 131.20 1261.0 0.09780 0.10340 0.14400 0.09791 0.1752 0.05533 ... 38.25 155.00 1731.0 0.11660 0.19220 0.3215 0.1628 0.2572 0.06637 0
566 16.60 28.08 108.30 858.1 0.08455 0.10230 0.09251 0.05302 0.1590 0.05648 ... 34.12 126.70 1124.0 0.11390 0.30940 0.3403 0.1418 0.2218 0.07820 0
567 20.60 29.33 140.10 1265.0 0.11780 0.27700 0.35140 0.15200 0.2397 0.07016 ... 39.42 184.60 1821.0 0.16500 0.86810 0.9387 0.2650 0.4087 0.12400 0
568 7.76 24.54 47.92 181.0 0.05263 0.04362 0.00000 0.00000 0.1587 0.05884 ... 30.37 59.16 268.6 0.08996 0.06444 0.0000 0.0000 0.2871 0.07039 1

569 rows × 31 columns

In [2]:
import matplotlib.pyplot as plt
%matplotlib inline
df.iloc[:,:10].plot(kind='bar');
Out[2]:
<AxesSubplot:>
In [3]:
X=df.iloc[:,:10]
from sklearn.preprocessing import Normalizer
ss=Normalizer()
x=ss.fit_transform(X)
In [4]:
y=pd.DataFrame(x)
y
Out[4]:
0 1 2 3 4 5 6 7 8 9
0 0.017835 0.010290 0.121739 0.992348 0.000117 0.000275 0.000298 0.000146 0.000240 0.000078
1 0.015432 0.013332 0.099706 0.994808 0.000064 0.000059 0.000065 0.000053 0.000136 0.000043
2 0.016268 0.017557 0.107407 0.993927 0.000091 0.000132 0.000163 0.000106 0.000171 0.000050
3 0.028947 0.051659 0.196649 0.978683 0.000361 0.000720 0.000612 0.000267 0.000658 0.000247
4 0.015557 0.010995 0.103584 0.994438 0.000077 0.000102 0.000152 0.000080 0.000139 0.000045
... ... ... ... ... ... ... ... ... ... ...
564 0.014508 0.015066 0.095550 0.995205 0.000075 0.000078 0.000164 0.000093 0.000116 0.000038
565 0.015872 0.022274 0.103447 0.994259 0.000077 0.000082 0.000114 0.000077 0.000138 0.000044
566 0.019179 0.032443 0.125127 0.991425 0.000098 0.000118 0.000107 0.000061 0.000184 0.000065
567 0.016179 0.023036 0.110034 0.993529 0.000093 0.000218 0.000276 0.000119 0.000188 0.000055
568 0.041059 0.129843 0.253549 0.957688 0.000278 0.000231 0.000000 0.000000 0.000840 0.000311

569 rows × 10 columns

In [5]:
y.plot(kind='bar')
Out[5]:
<AxesSubplot:>

Komponen Decision Tree

  • Decision tree menggabungkan antara data numerik dengan voting data(yes/or no)
  • Decision tree dimulai dari atas turun kebawah hingga tidak ada jawaban lagi, dari sini baru kita bisa mengklasifikasikan
  • Bagian yang teratas sendiri disebut root dan cabangnya adalah node

Decision tree memiliki 2 jenis node

  • setiap node internal merupakan pertanyaan yang terdapat dalam fitur. Hal ini merupakan hasil cabang yang berdasarkan jawaban
  • internal node memiliki panah yang mengarah ke dia sendiri dan ke luar internal node
  • Setiap node leaves merupakan label kelompok yang ditentukan oleh suara terbanyak dari training data yang mencapai leaves tersebut
  • leaves memiliki panah yang mengarah ke leaves sendiri, tapi tidak memiliki panah yang keluar

Cost Function of Split

  • Dalam kedua kasus decision tree cost function mencoba untuk menemukan cabang yang paling homogen, atau cabang yang memiliki kelompok dengan respons yang sama. Hal ini lebih meyakinkan bahwa input data uji akan mengikuti jalur tertentu.

Regression : sum(y — prediction)²

  • Sebagai contoh akan memprediksi harga rumah. Decision tree akan memulai splitting dengan merekam setiap fitur yang ada di training data. Nilai mean merupakan respon dari input training data bagian dari grup, Hal ini digunakan sebagai nilai prediksi Persamaan diatas diapplikasikan pada semua poin data and cost pada semua bagian splitting. Split dengan nilai cost paling kecil yang dipilih

Classification : G = sum(pk * (1 — pk))

  • Nilai Gini memberikan informasi mengenai bagaimana kualitas dari splitdengan melihat seberapa acak respon kelas yang berada dalam kelompok splitting. Pk adalah proporsi dari input kelas yang sama dan ditunjukkan dalam bagian grup. Kelas yang baik terbentuk kemurnian ketika suatu grup terdiri dari semua input dari kelas yang sama. Hal ini nilai Pk adalah 1 atau 0 sedangkan G=0.

Decision Tree Classifier

DecisionTreeClassifier adalah metode yang mampu melakukan klasifikasi multi-kelas pada dataset.

Parameters:

  • criterion : string, optional (default=”gini”) Fungsi untuk mengukur kualitas split. Kriteria yang didukung adalah "gini" untuk ketidakmurnian Gini dan "entropi" untuk perolehan informasi
  • splitter : string, optional (default=”best”) Strategi yang digunakan untuk memilih split di setiap node. Strategi yang didukung adalah "terbaik" untuk memilih split terbaik dan "acak" untuk memilih split acak terbaik.
  • max_depth : int or None, optional (default=None) Kedalaman maksimum pohon. Jika tidak ada, maka node diperluas sampai semua daun murni atau sampai semua daun mengandung kurang dari sampel min_samples_split
  • min_samples_split : int, float, optional (default=2) Jumlah sampel minimum yang diperlukan untuk membelah node internal: Jika int, maka pertimbangkan min_samples_split sebagai angka minimum.Jika float, maka min_samples_split adalah sebagian kecil dan ceil (min_samples_split * n_samples) adalah jumlah sampel minimum untuk setiap pemisahan
  • min_samples_leaf : int, float, optional (default=1) Jumlah minimum sampel yang diperlukan berada pada leaf node. Titik perpecahan pada kedalaman apa pun hanya akan dipertimbangkan jika meninggalkan training sampel pelatihan min_samples_leaf di masing-masing cabang kiri dan kanan. Ini mungkin memiliki efek model yang rapi, terutama dalam regresi. Jika int, maka pertimbangkan min_samples_leaf sebagai angka minimum. Jika float, maka min_samples_leaf adalah pecahan dan ceil (min_samples_leaf * n_samples) adalah jumlah sampel minimum untuk setiap node.

min_weight_fraction_leaf : float, optional (default=0.) Fraksi total minimum dari jumlah total bobot (dari semua sampel input) yang diperlukan berada pada simpul daun. Sampel memiliki bobot yang sama ketika sample_weight tidak disediakan.

  • max_features : int, float, string or None, optional (default=None) Jumlah fitur yang perlu dipertimbangkan saat mencari pemisahan terbaik:

If int, then consider max_features features at each split. If float, then max_features is a fraction and int(max_features * n_features) features are considered at each split. If “auto”, then max_features=sqrt(n_features). If “sqrt”, then max_features=sqrt(n_features). If “log2”, then max_features=log2(n_features). If None, then max_features=n_features.

  • random_state : int, RandomState instance or None, optional (default=None) Jika int, random_state adalah seed yang digunakan oleh generator angka acak; Jika instance RandomState, random_state adalah pembuat angka acak; Jika tidak ada, generator angka acak adalah turunan RandomState yang digunakan oleh np.random.
  • max_leaf_nodes : int or None, optional (default=None) Tumbuhkan pohon dengan max_leaf_nodes dengan mode best-first. Node terbaik didefinisikan sebagai pengurangan relatif dalam data pencilan. Jika tidak ada maka jumlah node daun yang tidak terbatas.

Atribut

  • classes_ : array of shape = [n_classes] Label kelas (masalah output tunggal), atau daftar array label kelas (masalah multi-output).

featureimportances : array of shape = [n_features] Kembalikan kepentingan fitur.

  • maxfeatures : int, Nilai yang disimpulkan dari max_features.
  • nclasses : int or list Jumlah kelas (untuk masalah output tunggal), atau daftar yang berisi jumlah kelas untuk setiap output (untuk masalah multi-output).
  • nfeatures : int Jumlah fitur saat fit dilakukan.
  • noutputs: int Jumlah output saat fit dilakukan.
  • tree_ : Tree object Objek Tree yang mendasarinya. Silakan merujuk ke bantuan (sklearn.tree._tree.Tree) untuk atribut objek tree dan Memahami struktur decision tree untuk penggunaan dasar atribut ini.

Seperti pengklasifikasi lain, DecisionTreeClassifier mengambil input dua array: array X, jarang atau padat, dengan ukuran [n_samples, n_fatures] memegang data training, dan array Y dari nilai integer, ukuran [n_samples], memegang label kelas untuk data training:

In [6]:
from sklearn import tree
from sklearn.datasets import load_iris
iris=load_iris()
X=iris.data
Y=iris.target
clf = tree.DecisionTreeClassifier()
clf = clf.fit(X, Y)

Setelah dipasang, model kemudian dapat digunakan untuk memprediksi kelas sampel:

In [7]:
Y
Out[7]:
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
       2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
       2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])
In [8]:
clf.predict([X[60,:]])
Out[8]:
array([1])

Probabilitas masing-masing kelas dapat diprediksi, yang merupakan sebagian kecil dari data training dari kelas yang sama dalam leaves:

DecisionTreeClassifier mampu klasifikasi biner (di mana labelnya [-1, 1]) dan klasifikasi multiclass (di mana labelnya adalah klasifikasi [0,…, K-1])

In [9]:
from sklearn.datasets import load_iris
from sklearn import tree
iris = load_iris()
clf = tree.DecisionTreeClassifier()
clf = clf.fit(iris.data, iris.target)

Plot tree dengan fungsi plot_tree:

In [16]:
plt.figure(figsize=(18,9))
tree.plot_tree(clf.fit(iris.data, iris.target));

Eksportir export_graphviz juga mendukung berbagai opsi estetika, termasuk pewarnaan node berdasarkan kelas mereka (atau nilai untuk regresi) dan menggunakan variabel eksplisit dan nama kelas jika diinginkan. Notebook Jupyter juga membuat plot ini sebaris secara otomatis:

In [12]:
import graphviz
dot_data = tree.export_graphviz(clf, out_file=None, feature_names=iris.feature_names,
                                class_names=iris.target_names,filled=True, rounded=True,
                                special_characters=True)  
graph = graphviz.Source(dot_data)  
graph 
Out[12]:
Tree 0 petal length (cm) ≤ 2.45 gini = 0.667 samples = 150 value = [50, 50, 50] class = setosa 1 gini = 0.0 samples = 50 value = [50, 0, 0] class = setosa 0->1 True 2 petal width (cm) ≤ 1.75 gini = 0.5 samples = 100 value = [0, 50, 50] class = versicolor 0->2 False 3 petal length (cm) ≤ 4.95 gini = 0.168 samples = 54 value = [0, 49, 5] class = versicolor 2->3 12 petal length (cm) ≤ 4.85 gini = 0.043 samples = 46 value = [0, 1, 45] class = virginica 2->12 4 petal width (cm) ≤ 1.65 gini = 0.041 samples = 48 value = [0, 47, 1] class = versicolor 3->4 7 petal width (cm) ≤ 1.55 gini = 0.444 samples = 6 value = [0, 2, 4] class = virginica 3->7 5 gini = 0.0 samples = 47 value = [0, 47, 0] class = versicolor 4->5 6 gini = 0.0 samples = 1 value = [0, 0, 1] class = virginica 4->6 8 gini = 0.0 samples = 3 value = [0, 0, 3] class = virginica 7->8 9 sepal length (cm) ≤ 6.95 gini = 0.444 samples = 3 value = [0, 2, 1] class = versicolor 7->9 10 gini = 0.0 samples = 2 value = [0, 2, 0] class = versicolor 9->10 11 gini = 0.0 samples = 1 value = [0, 0, 1] class = virginica 9->11 13 sepal length (cm) ≤ 5.95 gini = 0.444 samples = 3 value = [0, 1, 2] class = virginica 12->13 16 gini = 0.0 samples = 43 value = [0, 0, 43] class = virginica 12->16 14 gini = 0.0 samples = 1 value = [0, 1, 0] class = versicolor 13->14 15 gini = 0.0 samples = 2 value = [0, 0, 2] class = virginica 13->15

Klasifikasi Decision Tree langkah-perlangkah dapat dilihat di video berikut:

Decision Tree Regresion

Decision Tree juga dapat diterapkan untuk masalah regresi, menggunakan kelas DecisionTreeRegressor. Seperti dalam pengaturan klasifikasi, metode fit akan dianggap sebagai array argumen X dan y, hanya saja dalam hal ini y diharapkan memiliki nilai floating point juga nilai integer:

image.png

In [17]:
from sklearn import tree
X = [[0, 0], [2, 2]]
y = [0.5, 2.5]
clf = tree.DecisionTreeRegressor()
clf = clf.fit(X, y)
clf.predict([[1, 1]])
Out[17]:
array([0.5])

Perbedaan Decision Tree Classifier dengan Decision Tree Reggresion

  • Decision Tree Classifier targetnya adalah untuk mengklasifikasikan sesuai dengan kategori atau kelompok tertentu, contoh penumpang yang selamat atau mati.
  • Decision Tree Reggresion direpresentasikan dengan cara yang sama, hanya saja mereka memprediksi nilai terus menerus seperti harga rumah.

Daftar Pustaka

  • Devi. R. A, Nirmala. K. Prediction of Decision Tree :Attribute selection measure, 2013
  • J.R. Quinlan. C4. 5: programs for machine learning. Morgan Kaufmann, 1993.
  • L. Breiman, J. Friedman, R. Olshen, and C. Stone. Classification and Regression Trees. Wadsworth, Belmont, CA, 1984.
  • T. Hastie, R. Tibshirani and J. Friedman. Elements of Statistical Learning, Springer, 2009.