Qu'est-ce qu'un arbre de décision?

--Un arbre de décision est un algorithme qui crée une structure arborescente en répétant la division des données basée sur un simple ** critère **.

-Applicable aux ** problèmes de classification / régression **

――L'arbre de décision est rarement utilisé seul. (Appliquer, forêt aléatoire, etc.)

Comment déterminez-vous le montant et le seuil de fonctionnalité standard?

** (Pureté avant fractionnement) - (Pureté après fractionnement) ** Déterminez les critères de division afin que

Autrement dit, la division est effectuée de sorte que ** (impureté après division) devienne le minimum **.

** "Impureté" ** est un indice qui montre combien de classes différentes d'observations sont mélangées.

Pour les problèmes de classification, idéalement, il n'y a qu'une seule classe d'observations par nœud (impureté = 0)

Fonction représentant l'impureté

Taux de mauvaise classification (non différentiable)
** Indice de Gini (différenciable) ** --Entropie croisée (différenciable)

Peut être mentionné. (Le paramètre sklearn defalut est défini sur ** indice Gini **)

Exemple concret

** Gauche: 1- (0/54) ^ 2- (49/54) ^ 2- (5/54) ^ 2 = 0,168 **

** Droite: 1- (0/46) ^ 2- (1/46) ^ 2- (45/46) ^ 2 = 0,043 **

Par conséquent, ** pureté globale ** est ** 54/100 x 0,168 + 46/100 x 0,043 = 0,111 ** (impureté après division)

Avantages et inconvénients de l'arbre de décision

mérite

--Facile à comprendre

Applicable à la fois à la classification et à la régression
Largement applicable à tous les problèmes
Pas besoin de standardiser les données ou de créer des variables factices

Démérite

--Grande variance (* sensible aux valeurs aberrantes **)

** Facile à surapprendre ** (modèle non paramétrique)
La surface de prédiction n'est pas lisse

Comment éviter le surapprentissage?

--Il est important d'ajuster les ** paramètres ** pour éviter le surapprentissage.

En d'autres termes, définissez la limite supérieure de la profondeur de l'arbre ** (max-depth) ** et le nombre minimum d'observations ** (min_samples_leaf) ** qu'un nœud doit avoir.

Expérience ① (problème de classification)

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split

moons=make_moons(n_samples=200,noise=0.1,random_state=0)

X=moons[0]
y=moons[1]

X_train,X_test,y_train,y_test=train_test_split(X,y,random_state=0)

from sklearn.tree import DecisionTreeClassifier

tree_clf=DecisionTreeClassifier(min_samples_leaf=10).fit(X_train,y_train) #par défaut pas de limite supérieure
tree_clf_3=DecisionTreeClassifier(max_depth=3).fit(X_train,y_train)

print(tree_clf.score(X_test,y_test))
print(tree_clf_3.score(X_test,y_test))

from matplotlib.colors import ListedColormap

def plot_decision_boundary(model,X,y):
    _x1 = np.linspace(X[:,0].min()-0.5,X[:,0].max()+0.5,100)
    _x2 = np.linspace(X[:,1].min()-0.5,X[:,1].max()+0.5,100)
    x1,x2 = np.meshgrid(_x1,_x2)
    X_new=np.c_[x1.ravel(),x2.ravel()]
    y_pred=model.predict(X_new).reshape(x1.shape)
    custom_cmap=ListedColormap(["mediumblue","orangered"])
    plt.contourf(x1,x2,y_pred,cmap=custom_cmap,alpha=0.3)
    
def plot_dataset(X,y):
    plt.plot(X[:,0][y==0],X[:,1][y==0],"bo",ms=15)
    plt.plot(X[:,0][y==1],X[:,1][y==1],"r^",ms=15)
    plt.xlabel("$x_1$",fontsize=30)
    plt.ylabel("$x_2$",fontsize=30,rotation=0)

plt.figure(figsize=(24,8))
plt.subplot(121)
plot_decision_boundary(tree_clf,X,y)
plot_dataset(X,y)

plt.subplot(122)
plot_decision_boundary(tree_clf_3,X,y)
plot_dataset(X,y)

plt.show()

Expérience ② (problème de retour)

import mglearn
from sklearn.tree import DecisionTreeRegressor

reg_X,reg_y=mglearn.datasets.make_wave(n_samples=100)

tree_reg=DecisionTreeRegressor().fit(reg_X,reg_y)
tree_reg_3=DecisionTreeRegressor(max_depth=3).fit(reg_X,reg_y)

def plot_regression_predicitons(model,X,y):
    x1 = np.linspace(X.min()-1,X.max()+1,500).reshape(-1,1)
    y_pred=model.predict(x1)
    plt.xlabel("x",fontsize=30)
    plt.ylabel("y",fontsize=30,rotation=0)
    plt.plot(X,y,"bo",ms=15)
    plt.plot(x1,y_pred,"r-",linewidth=6)
    
plt.figure(figsize=(24,8))

plt.subplot(121)
plot_regression_predicitons(tree_reg,reg_X,reg_y)

plt.subplot(122)
plot_regression_predicitons(tree_reg_3,reg_X,reg_y)

plt.show()