[Python] Tutoriel personnel sur l'arbre de décision

Il servira de feuille de mise en conserve.

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

L'arbre de décision est un modèle d'apprentissage automatique largement utilisé dans la prédiction de classification et de régression. Il a une ** structure hiérarchique ** composée de questions auxquelles on peut répondre Oui / Non. Dans l'arbre de décision, vous pouvez voir dans quelle mesure chaque variable explicative affecte la variable objectif. Elle se ramifie en répétant la division, mais la variable qui est divisée en premier a plus d'influence. Il peut être considéré comme important.

Ce classificateur peut être exprimé comme un modèle de classification ** qui discrimine ** 4 classes de données par trois grandeurs de caractéristiques. En utilisant un algorithme d'apprentissage automatique, un tel modèle peut apprendre des données d'entraînement et en fait dessiner un arbre comme décrit ci-dessus.

Caractéristiques de l'arbre de décision

mérite

• Relativement facile à interpréter car l'arbre de décision peut ** visualiser ** les résultats
• Non affecté par différentes échelles de fonctionnalités, aucun prétraitement comme la standardisation n'est requis **

Démérite

• ** Forte dépendance aux données d'entraînement **, peu importe la façon dont vous ajustez les paramètres, vous risquez de ne pas obtenir le niveau d'arborescence souhaité
• ** Facile à surapprendre ** A tendance à avoir de faibles performances de généralisation

Méthode d'évaluation

Matrice confuse

La matrice de confusion est une matrice de base lorsqu'on considère l'évaluation d'un modèle de classification et représente la relation entre la valeur prédite et la valeur observée du modèle. Plus précisément, comme le montre la figure ci-dessous, il existe quatre catégories: ** vrai positif ** (vrai positif), ** vrai négatif ** (vrai négatif), ** faux positif ** (faux positif), ** faux A un négatif ** (faux négatif).

Taux de réponse correct (précision)

C'est le rapport de la prédiction à l'ensemble, et peut être calculé comme suit. $ Taux de réponse correct = \ frac {TP + TN} {TP + FP + FN + TN} $

Précision

C'est le rapport des données prédites positives qui est réellement positif et peut être calculé comme suit. $ Taux d'ajustement = \ frac {TP} {TP + FP} $

Rappel

C'est le rapport entre ceux qui sont réellement positifs et ceux qui sont prédits positifs, et peut être calculé comme suit. $ Taux de rappel = \ frac {TP} {TP + FN} $

Implémenté en Python

• En supposant une exécution avec le notebook Jupyter

Ensemble de données de données

Un ensemble de données qui résume les données de diagnostic du cancer du sein de scikit-learn. Elle est bénigne (1) et maligne (0).

Bibliothèque à utiliser

[In]

#Bibliothèque utilisée pour le traitement des données
import pandas as pd
import numpy as np

#Bibliothèque utilisée pour la visualisation des données
import matplotlib.pyplot as plt; plt.style.use('ggplot')
import matplotlib.gridspec as gridspec
import seaborn as sns
%matplotlib inline

#Bibliothèque d'apprentissage automatique
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import confusion_matrix
from sklearn.metrics import accuracy_score
from sklearn import metrics

Système constant

[In]

#constant
RESPONSE_VARIABLE = 'cancer' #Variable objective
TEST_SIZE = 0.2
RANDOM_STATE = 42

Lire les données

[In]

#Lire les données(scikit-apprendre les données sur le cancer)
from sklearn.datasets import load_breast_cancer

data = load_breast_cancer()
cancer = pd.DataFrame(data=data.data, columns=data.feature_names)
cancer[RESPONSE_VARIABLE] = data.target

#Afficher les 5 premières lignes
cancer.head()

Tableau de base

[In]

#Vérifier les statistiques
cancer.describe()

[In]

#Nombre de variables objectives
cancer[RESPONSE_VARIABLE].value_counts()

[Out]

1    357
0    212
Name: cancer, dtype: int64

[In]

#Confirmation des valeurs manquantes
cancer.isnull().sum()

[Out]

mean radius                0
mean texture               0
mean perimeter             0
mean area                  0
mean smoothness            0
mean compactness           0
mean concavity             0
mean concave points        0
mean symmetry              0
mean fractal dimension     0
radius error               0
texture error              0
perimeter error            0
area error                 0
smoothness error           0
compactness error          0
concavity error            0
concave points error       0
symmetry error             0
fractal dimension error    0
worst radius               0
worst texture              0
worst perimeter            0
worst area                 0
worst smoothness           0
worst compactness          0
worst concavity            0
worst concave points       0
worst symmetry             0
worst fractal dimension    0
cancer                     0
dtype: int64

Répartition des données

[In]

#Divisé en données d'entraînement et données de test
train, test = train_test_split(cancer, test_size=TEST_SIZE, random_state=RANDOM_STATE)

#Diviser en variables explicatives et variables objectives
X_train = train.drop(RESPONSE_VARIABLE, axis=1)
y_train = train[RESPONSE_VARIABLE].copy()

X_test = test.drop(RESPONSE_VARIABLE, axis=1)
y_test = test[RESPONSE_VARIABLE].copy()

Visualisation de données

[In]

#Visualisez la distribution des variables objectives pour chaque fonctionnalité
features = X_train.columns
legend= ['Benign','Malignant']
plt.figure(figsize=(20,32*4))
gs = gridspec.GridSpec(32, 1)
for i, col in enumerate(train[features]):
    ax = plt.subplot(gs[i])
    sns.distplot(train[col][train.cancer == 0],bins=50, color='crimson')
    sns.distplot(train[col][train.cancer == 1],bins=50, color='royalblue')
    plt.legend(legend)

Sélection de fonctionnalité

En utilisant RandomForestClassifier () de Scikit-learn, il est possible de confirmer l '"importance" de chaque quantité de fonctionnalité comme feature_importances_.

[In]

#Sélection de fonctionnalité
RF = RandomForestClassifier(n_estimators = 250, random_state = 42)
RF.fit(X_train, y_train)

:[Out]
RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',
            max_depth=None, max_features='auto', max_leaf_nodes=None,
            min_impurity_decrease=0.0, min_impurity_split=None,
            min_samples_leaf=1, min_samples_split=2,
            min_weight_fraction_leaf=0.0, n_estimators=250, n_jobs=None,
            oob_score=False, random_state=42, verbose=0, warm_start=False)

[In]

#Fonctions de sortie par ordre décroissant d'importance
features = X_train.columns
importances = RF.feature_importances_

importances_features = sorted(zip(map(lambda x: round(x, 2), RF.feature_importances_), features), reverse=True)

for i in importances_features:
    print(i)

[Out]

(0.13, 'worst perimeter')
(0.13, 'worst concave points')
(0.13, 'worst area')
(0.11, 'mean concave points')
(0.07, 'worst radius')
(0.05, 'mean radius')
(0.05, 'mean concavity')
(0.04, 'worst concavity')
(0.04, 'mean perimeter')
(0.04, 'mean area')
(0.02, 'worst texture')
(0.02, 'worst compactness')
(0.02, 'radius error')
(0.02, 'mean compactness')
(0.02, 'area error')
(0.01, 'worst symmetry')
(0.01, 'worst smoothness')
(0.01, 'worst fractal dimension')
(0.01, 'perimeter error')
(0.01, 'mean texture')
(0.01, 'mean smoothness')
(0.01, 'fractal dimension error')
(0.01, 'concavity error')
(0.0, 'texture error')
(0.0, 'symmetry error')
(0.0, 'smoothness error')
(0.0, 'mean symmetry')
(0.0, 'mean fractal dimension')
(0.0, 'concave points error')
(0.0, 'compactness error')

Top 5 des résultats de la sélection aléatoire d'entités forestières

• worst perimeter
• worst concave points
• worst area
• mean concave points
• worst radius

[In]

#Obtenez le top 5 sous forme de liste
feature_list = [value for key, value in important_features if key >= 0.06]
feature_list

[Out]

['worst perimeter',
 'worst concave points',
 'worst area',
 'mean concave points',
 'worst radius']

[In]

#Concentrez les données d'entraînement et de test uniquement sur les fonctionnalités les plus importantes
X_train = X_train[feature_list]
X_test = X_test[feature_list]

[In]

#Vérifiez à nouveau la distribution de la variable objectif
legend= ['Benign','Malignant']
plt.figure(figsize=(20,32*4))
gs = gridspec.GridSpec(32, 1)
for i, col in enumerate(train[feature_list]):
    ax = plt.subplot(gs[i])
    sns.distplot(train[col][train.cancer == 0],bins=50, color='crimson')
    sns.distplot(train[col][train.cancer == 1],bins=50, color='royalblue')
    plt.legend(legend)

Apprentissage / prédiction / évaluation

[In]

#Apprentissage
clf = DecisionTreeClassifier(max_depth=4)
clf = clf.fit(X_train, y_train)

[In]

#Prédiction à l'aide des fonctionnalités des données d'entraînement
y_pred = clf.predict(X_train)

[In]

def drawing_confusion_matrix(y: pd.Series, pre: np.ndarray) -> None:
    """
Une fonction qui dessine une matrice de confusion
    
    @param y:Variable objective
    @param pre:Valeur attendue
    """
    confmat = confusion_matrix(y, pre)
    fig, ax = plt.subplots(figsize=(5, 5))
    ax.matshow(confmat, cmap=plt.cm.Blues, alpha=0.3)
    for i in range(confmat.shape[0]):
        for j in range(confmat.shape[1]):
            ax.text(x=j, y=i, s=confmat[i, j], va='center', ha='center')
    plt.title('Predicted value')
    plt.ylabel('Measured value')
    plt.rcParams["font.size"] = 15
    plt.tight_layout() 
    plt.show()

[In]

def calculation_evaluations(y: pd.Series, pre: np.ndarray) -> None:
    """
Une fonction qui calcule et génère respectivement le taux de réponse, le taux de précision et le taux de rappel corrects.
    
    @param y:Variable objective
    @param pre:Valeur attendue
    """
    print('Taux de réponse correct: {:.3f}'.format(metrics.accuracy_score(y, pre)))
    print('Taux de conformité: {:.3f}'.format(metrics.precision_score(y, pre)))
    print('Rappel: {:.3f}'.format(metrics.recall_score(y, pre)))

[In]

drawing_confusion_matrix(y_train, y_pred)
calculation_evaluations(y_train, y_pred)

:[Out]
Taux de réponse correct: 0.969
Taux de conformité: 0.979
Rappel: 0.972

163 en TP (en haut à gauche) est le nombre réel de malins que le modèle prédisait malins. 9 en FP (en bas à droite) est un nombre qui devrait être malin et pas réellement malin. Le FN (en haut à droite) de 6 est en fait malin mais devrait être bénin.

[In]

#Prédire les données de test avec un modèle entraîné
y_pred_test = clf.predict(X_test)

[In]

drawing_confusion_matrix(y_test, y_pred_test)
calculation_evaluations(y_test, y_pred_test)

[Out]

Taux de réponse correct: (TP + TN)/(TP + TN + FP + FN)
Taux de réponse correct: 0.939
Taux de conformité: TP/(TP + FP)
Taux de conformité: 0.944
Rappel: TP/(TP + FN)
Rappel: 0.958