Lectures des données et chargement des librairies

J'ai besoin de la librairie pyreadr qui permet de lire un fichier .rda de R.

import pyreadr as pyR
import numpy as np
import pandas as pd
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
from sklearn.model_selection import RandomizedSearchCV, GridSearchCV
from sklearn import tree
from sklearn.metrics import mean_squared_error, mean_absolute_error
import seaborn as sns
import matplotlib.pyplot as plt

import os
os.getcwd()
#!pip install pyreadr

insurance = pyR.read_r('/home/sedki/Dropbox/enseignement/M2SDS/data/insurance.rda')
print(type(insurance))
print(insurance.keys())
df = insurance['insurance']
df.head()

Organisation du jeu données + train et test

X = pd.get_dummies(df.drop(columns=['charges']))
print(X.head())

y = df['charges']
print(X.shape)
print(y.shape)


x_train,x_test,y_train,y_test = train_test_split(X,y)
print(x_train.shape)
print(x_test.shape)

Arbre de décision

regtree = tree.DecisionTreeRegressor(random_state=0)
regtree.fit(x_train,y_train)
y_train_pred = regtree.predict(x_train)
y_test_pred = regtree.predict(x_test)

plt.figure(figsize=(20,20))
features = list(X.columns)
tree.plot_tree(regtree,feature_names=features,filled=True)
plt.show()

print("Erreur absolue moyenne d'apprentissage : ", mean_absolute_error(y_train, y_train_pred))
print("Erreur absolue moyenne de test : " ,mean_absolute_error(y_test, y_test_pred))

print("Racine de l'erreur quadratique moyenne d'apprentissage : ", np.sqrt(mean_squared_error(y_train, y_train_pred)))
print("Racine de l'erreur quadratique moyenne de test :", np.sqrt(mean_squared_error(y_test, y_test_pred)))

Pré-élagage (une approche un peu bulldozer)

Le pré-élagage n'est rien d'autre que l'arrêt de la croissance de l'arbre de décision à un stade précoce. Pour cela, nous pouvons limiter la croissance des arbres en fixant des contraintes. Nous pouvons agir sur les paramètres tels que max_depth , min_samples etc.

Une façon efficace de procéder est de faire une recherche sur une grille de ces paramètres et de choisir les valeurs optimales qui donnent de meilleures performances sur les données de test.

Pour l'instant, nous allons contrôler les paramètres suivants :

• max_depth : profondeur maximale de l'arbre de décision
• min_sample_split : Le nombre minimum d'échantillons requis pour diviser un nœud interne :
• min_samples_leaf : Le nombre minimum d'échantillons requis pour être à un nœud feuille.

params = {'max_depth': [2,4,6,8,10,12],
         'min_samples_split': [2,3,4],
         'min_samples_leaf': [1,2,3,4,5,6,7,8]}

regtree = tree.DecisionTreeRegressor()
gcv = GridSearchCV(estimator=regtree,param_grid=params, n_jobs=-1)
gcv.fit(x_train,y_train)
print(gcv.best_params_)

model = gcv.best_estimator_
model.fit(x_train,y_train)
y_train_pred = model.predict(x_train)
y_test_pred = model.predict(x_test)

print("Erreur absolue moyenne d'apprentissage : ", mean_absolute_error(y_train, y_train_pred))
print("Erreur absolue moyenne de test : " ,mean_absolute_error(y_test, y_test_pred))

print("Racine de l'erreur quadratique moyenne d'apprentissage : ", np.sqrt(mean_squared_error(y_train, y_train_pred)))
print("Racine de l'erreur quadratique moyenne de test :", np.sqrt(mean_squared_error(y_test, y_test_pred)))

plt.figure(figsize=(20,20))
features = list(X.columns)
tree.plot_tree(model,feature_names=features,filled=True)
plt.show()

Le vrai élagage (Cost Complexity Pruning)

Les arbres de décision peuvent facilement se retrouver en situation de surajustement. Une façon de l'éviter est de limiter la croissance des arbres en fixant des contraintes. Nous pouvons limiter des paramètres tels que max_depth , min_samples etc. Mais le moyen le plus efficace est d'utiliser des méthodes d'élagage comme l'élagage Cost Complexity Pruning. Cela permet d'améliorer la précision test et d'obtenir un meilleur modèle.

L'élagage par Cost Complexity Pruning consiste à trouver le bon paramètre pour $\alpha$. Nous allons obtenir les valeurs de $\alpha$ pour cet arbre et vérifier la précision avec les arbres élagués. Petite vidéo si vous avez un peu de temps.

regtree_0 = tree.DecisionTreeRegressor(min_samples_leaf=1, min_samples_split=2, max_depth = 1000)
path = regtree_0.cost_complexity_pruning_path(x_train, y_train)
ccp_alphas, impurities = path.ccp_alphas, path.impurities
print(ccp_alphas)

# Pour chaque alpha, nous allons ajouter notre modèle à une liste
regtrees = []
for ccp_alpha in ccp_alphas:
    regtree = tree.DecisionTreeRegressor(random_state=0, ccp_alpha=ccp_alpha)
    regtree.fit(x_train, y_train)
    regtrees.append(regtree)

Nous allons supprimer le dernier élément dans regtrees et ccp_alphas, car c'est l'arbre trivial avec un seul nœud.

train_err = []
test_err = []
for regtree in regtrees:
    y_train_pred = regtree.predict(x_train)
    y_test_pred = regtree.predict(x_test)
    train_err.append(mean_absolute_error(y_train_pred,y_train))
    test_err.append(mean_absolute_error(y_test_pred,y_test))

plt.scatter(ccp_alphas,train_err)
plt.scatter(ccp_alphas,test_err)
plt.plot(ccp_alphas,train_err,label='train_error',drawstyle="steps-post")
plt.plot(ccp_alphas,test_err,label='test_error',drawstyle="steps-post")
plt.legend()
plt.title('error vs alpha')
plt.xscale('log') ## on est obligé de passer à l'échelle log pour voir quelque chose
plt.show()

ccp_optim = ccp_alphas[np.argmin(test_err)]
print(ccp_optim)
regtree_ = tree.DecisionTreeRegressor(random_state=0,ccp_alpha=ccp_optim)
regtree_.fit(x_train,y_train)
y_train_pred = regtree_.predict(x_train)
y_test_pred = regtree_.predict(x_test)
print("Erreur absolue moyenne d'apprentissage : ", mean_absolute_error(y_train, y_train_pred))
print("Erreur absolue moyenne de test : " ,mean_absolute_error(y_test, y_test_pred))

print("Racine de l'erreur quadratique moyenne d'apprentissage : ", np.sqrt(mean_squared_error(y_train, y_train_pred)))
print("Racine de l'erreur quadratique moyenne de test :", np.sqrt(mean_squared_error(y_test, y_test_pred)))

plt.figure(figsize=(20,20))
features = list(X.columns)
tree.plot_tree(regtree_,feature_names=features,filled=True)
plt.show()

params = {'ccp_alpha' : ccp_alphas}
gcv = GridSearchCV(estimator=regtree,param_grid=params, n_jobs=-1)
gcv.fit(x_train,y_train)
print(gcv.best_params_['ccp_alpha'])

regtree_cv = tree.DecisionTreeRegressor(random_state=0,ccp_alpha=gcv.best_params_['ccp_alpha'])
regtree_cv.fit(x_train,y_train)
y_train_pred = regtree_cv.predict(x_train)
y_test_pred = regtree_cv.predict(x_test)
print("Erreur absolue moyenne d'apprentissage : ", mean_absolute_error(y_train, y_train_pred))
print("Erreur absolue moyenne de test : " ,mean_absolute_error(y_test, y_test_pred))

print("Racine de l'erreur quadratique moyenne d'apprentissage : ", np.sqrt(mean_squared_error(y_train, y_train_pred)))
print("Racine de l'erreur quadratique moyenne de test :", np.sqrt(mean_squared_error(y_test, y_test_pred)))