L'Élagage Des Arbres De Décision

Salut les gars ci-dessous est un extrait de l'arbre de décision comme il est assez énorme.

L'Élagage Des Arbres De Décision

Comment faire de l'arbre cesser de croître quand le plus bas valeur dans un nœud de moins de 5 ans. Voici le code pour produire de l'arbre de décision. Sur SciKit - Decission De L'Arbre nous pouvons voir que la seule façon de le faire est par min_impurity_decrease mais je ne suis pas sûr de comment elle fonctionne.

import numpy as np
import pandas as pd
from sklearn.datasets import make_classification
from sklearn.ensemble import RandomForestClassifier
from sklearn.tree import DecisionTreeClassifier
X, y = make_classification(n_samples=1000,
n_features=6,
n_informative=3,
n_classes=2,
random_state=0,
shuffle=False)
# Creating a dataFrame
df = pd.DataFrame({'Feature 1':X[:,0],
'Feature 2':X[:,1],
'Feature 3':X[:,2],
'Feature 4':X[:,3],
'Feature 5':X[:,4],
'Feature 6':X[:,5],
'Class':y})
y_train = df['Class']
X_train = df.drop('Class',axis = 1)
dt = DecisionTreeClassifier( random_state=42)                
dt.fit(X_train, y_train)
from IPython.display import display, Image
import pydotplus
from sklearn import tree
from sklearn.tree import _tree
from sklearn import tree
import collections
import drawtree
import os  
os.environ["PATH"] += os.pathsep + 'C:\\Anaconda3\\Library\\bin\\graphviz'
dot_data = tree.export_graphviz(dt, out_file = 'thisIsTheImagetree.dot',
feature_names=X_train.columns, filled   = True
, rounded  = True
, special_characters = True)
graph = pydotplus.graph_from_dot_file('thisIsTheImagetree.dot')  
thisIsTheImage = Image(graph.create_png())
display(thisIsTheImage)
#print(dt.tree_.feature)
from subprocess import check_call
check_call(['dot','-Tpng','thisIsTheImagetree.dot','-o','thisIsTheImagetree.png'])

Mise à jour

Je pense que min_impurity_decrease peut être aussi un moyen d'aider à atteindre l'objectif. Comme peaufinage min_impurity_decrease ne fait tailler l'arbre. Quelqu'un peut-il m'expliquer min_impurity_decrease.

Je suis en train d'essayer de comprendre l'équation de scikit apprendre, mais je ne suis pas sûr de ce qui est la valeur de right_impurity et left_impurity.

N = 256
N_t = 256
impurity = ??
N_t_R = 242
N_t_L = 14
right_impurity = ??
left_impurity = ??
New_Value = N_t / N * (impurity - ((N_t_R / N_t) * right_impurity)
- ((N_t_L / N_t) * left_impurity))
New_Value

Mise à jour 2

Au lieu de l'élagage à une certaine valeur, nous pruneau sous certaines conditions.
comme
Nous n'avons divisé à 6/4 et 5/5, mais pas à 6000/4 ou 5000/5. Disons que si une valeur est en dessous d'un certain pourcentage en comparaison avec sa valeur voisine dans le nœud, plutôt que d'une certaine valeur.

      11/9
/       \
6/4       5/5
/   \     /   \
6/0  0/4  2/2  3/3
  • Quelle est la valeur que représentent-ils? min_impurity_decrease est applicable à la division qui peut se produire dans un nœud, et de ne pas considérer une valeur du noeud courant, mais l'augmentation de la pureté dans les enfants si l'on veut diviser le nœud.
  • le valeur terme est dans l'arbre de décision sous le terme d'échantillons
  • La gauche et la droite de l'impureté sont les impuretés des échantillons dans le gauche de l'enfant et de droit de l'enfant, respectivement. (calculé par le critère argument)
  • Je ne pense pas que vous serez en mesure de le faire avec la decission de l'arbre de SciKit, à moins que vous le saviez peut-être le max-depth ou le nombre d'échantillons lorsque la valeur de moins de 5 ans va se produire. Peut-être qu'il est possible de parcourir l'arbre après la construction? L'arbre est situé dans tree_ de l'objet classificateur
  • Vous devez spécifier quel est le critère qui vous êtes en utilisant: soit de gini ou l'entropie. Vous ne pouvez pas mettre en place votre propre fonction.
  • Pas selon la documentation: "le Critère : string, optionnel (par défaut=”gini”) => La fonction de mesure de la qualité d'une division. Les critères pris en charge sont “gini” pour le coefficient de Gini de l'impureté et de “l'entropie” pour le gain d'informations."
  • N'est-ce pas juste min_samples_split?
  • min_samples split est pour le nombre total d'échantillons dans le nœud. La question est, la valeur la plus basse dans le nœud. par exemple [400, 1] vous voulez qu'il cesse de fractionnement. À l'aide de min_samples_split, il sera toujours divisés
  • Jetez un oeil à cette discussion, ressemble à un problème similaire à essayer de résoudre.
  • vous avez absolument raison ! C'est exactement ma question

InformationsquelleAutor | 2018-03-22
  1. 17

    Directement restreindre la valeur la plus faible (nombre d'occurrences d'une classe particulière) d'une feuille ne peut pas être fait avec min_impurity_decrease ou de tout autre intégrée dans les critères d'arrêt.

    Je pense que la seule façon vous pouvez accomplir cela sans modifier le code source de scikit-learn est à post-prune votre arbre. Pour ce faire, vous pouvez simplement parcourir l'arbre et retirez tous les enfants des nœuds avec un minimum de classe comptent moins de 5 (ou de toute autre condition que vous pouvez penser). Je vais poursuivre votre exemple:

    from sklearn.tree._tree import TREE_LEAF
def prune_index(inner_tree, index, threshold):
if inner_tree.value[index].min() < threshold:
# turn node into a leaf by "unlinking" its children
inner_tree.children_left[index] = TREE_LEAF
inner_tree.children_right[index] = TREE_LEAF
# if there are shildren, visit them as well
if inner_tree.children_left[index] != TREE_LEAF:
prune_index(inner_tree, inner_tree.children_left[index], threshold)
prune_index(inner_tree, inner_tree.children_right[index], threshold)
print(sum(dt.tree_.children_left < 0))
# start pruning from the root
prune_index(dt.tree_, 0, 5)
sum(dt.tree_.children_left < 0)

    ce code affichera la première 74, puis 91. Cela signifie que le code a créé 17 nouveaux nœuds feuilles (par pratiquement la suppression des liens vers leurs ancêtres). L'arbre, qui a regardé avant comme

    L'Élagage Des Arbres De Décision

    ressemble maintenant à

    L'Élagage Des Arbres De Décision

    de sorte que vous pouvez voir qui est, en fait, a beaucoup diminué.

    • mais cela signifie qu'il est seulement taillées dans le diagramme et pas vraiment dans le calcul? Donc si j'ai l'impression que la décision de chemin d'accès d'une instance à correspondre à la totalité de l'arbre, plutôt que de l'arbre élagué droit ?
    • Non, l'arbre est taillé dans le calcul. Les nœuds qui ont été taillés loin encore exister dans la mémoire, mais ils ne sont jamais atteint lorsque l'arbre est utilisé pour la prédiction.
    • Cela fait des miracles ! Je vous remercie.
    • J'ai utilisé cette solution pour écrire mon propre, l'exportation de graphviz et la prédiction fonctionne. max_depth n'est évidemment pas mise à jour, est-il autre chose que je devrais savoir avant de déployer un modèle taillé de cette façon? Avez-vous des problèmes par la suite?
    • non, je n'ai pas de problème avec ces solutions
    • vous êtes invité à prolonger ma réponse à modifier les paramètres à utiliser tout vous le souhaitez 🙂
    • J'ai couru à l'Arbre de Décision classificateur 20 fois sur un ensemble de formation, à chaque itération à l'aide d'une autre valeur de seuil, de 1 à 20. Étonnamment, la croix de précision de validation a diminué de façon monotone comme seuil (c'est à dire de la taille) a augmenté. C'est le contraire de ce que je m'attendrais à la taille, qui est destiné à réduire la complexité du modèle et, par conséquent, le surajustement. Cela m'indique que quelque chose est fondamentalement mauvais avec cet algorithme, ou que j'ai raté quelque chose et fais quelque chose de mal. Des idées sur ce point?
    • L'élagage améliore la précision de validation si votre modèle est surajustement - dans ce cas, l'élagage des combats extrapolation abusive. Toutefois, si votre modèle est en fait underfitting vos données d'entraînement (par exemple, si vous avez beaucoup d'observations, peu de fonctionnalités, et certaines contraintes déjà imposrd sur le modèle), puis l'élagage fait le modèle underfit encore plus.
    • Toutefois, vous devriez vous attendre à l'écart entre la formation et de la validation de la précision diminue à mesure que vous taillez l'arbre de plus en plus. Si ça n'arrive pas, alors il y a effectivement un bug.
    • Si ce bug se passe vraiment, merci de poster une autre question à ce sujet, avec reproductible code.

    InformationsquelleAutor David Dale
  2. 1

    Edit : Ce n'est pas correct que @SBylemans et @Viktor point dans les commentaires. Je ne suis pas la suppression de la réponse, puisque quelqu'un d'autre peut également penser que c'est la solution.

    Ensemble min_samples_leaf à 5.

    min_samples_leaf :

    Le nombre minimum d'échantillons nécessaires pour être à un nœud feuille:

    Mise à jour : je pense qu'il ne peut être fait avec min_impurity_decrease. Pensez à le scénario suivant : 

          11/9
/         \
6/4       5/5
/   \     /   \
6/0  0/4  2/2  3/3

    Selon votre règle, vous ne voulez pas de split nœud 6/4 depuis le 4 est à moins de 5 mais vous, vous voulez diviser 5/5 nœud. Toutefois, le fractionnement de l' 6/4 nœud 0.48 gain d'informations et de fractionnement 5/5 a 0 le gain d'informations.

    • Il ne dit pas qu'5 représente le nombre d'échantillons dans le nœud
    • c'est incorrect ! min_damples_leaf, est dans le nœud feuille. La question est de savoir, en regardant la valeur minimale dans le nœud, arrêtez de fractionnement si il est inférieur à une certaine valeur.
    • Je vois. J'ai mal compris la question, mais je pense que ce que vous recherchez ne peut pas être fait avec min_impurity_decrease. Vérifier la mise à jour de la section de la réponse pour un exemple.
    • belle explication
    • J'ai légèrement mise à jour de la question en vertu de la partie de mise à jour. Peut-on changer un pourcentage de l'autre? Par exemple découper à 6/4 et 5/5, mais pas à 6000/4 ou 5000/5. Disons que, si une valeur est inférieure à un certain pourcentage, plutôt que d'une certaine valeur.
    InformationsquelleAutor Seljuk Gülcan
  3. 0

    Il est intéressant de noter, min_impurity_decrease n'a pas l'air comme si elle allait permettre à la croissance de tous les nœuds que vous avez indiqué dans l'extrait de code que vous avez fourni (la somme des impuretés après le partage est égal à la division de l'impureté, de sorte que il n'y a pas de impureté diminution). Cependant, bien qu'il ne vous donne pas exactement le résultat que vous souhaitez (de résilier le nœud si la valeur la plus faible est de moins de 5 ans), cela peut vous donner quelque chose de similaire.

    Si mon test est droit, l'officiel docs le faire paraître plus compliquée qu'elle ne l'est en réalité. Il suffit de prendre la valeur la plus faible du potentiel du noeud parent, puis de soustraire la somme des valeurs plus faibles de la proposition de nouveaux nœuds - c'est le brut impureté de réduction. Puis diviser par le nombre total d'échantillons dans la ensemble de l'arbre - ce qui vous donne la fractions d'impureté diminution atteint que si le nœud est de split.

    Si vous avez 1000 échantillons, et un nœud avec une faible valeur de 5 (c'est à dire 5 "impuretés"), 5/1000 représente le maximum d'impuretés diminution que vous pourriez réaliser si ce nœud est parfaitement séparé. Donc si ce réglage est min_impurity_decrease de de 0,005 approximatif de l'arrêt de la feuille avec un <5 impuretés. Il serait effectivement arrêter la plupart des feuilles avec un peu plus de 5 impuretés (en fonction des impuretés résultant de la proposition de scission), de sorte qu'il n'est qu'une approximation, mais du mieux que je peux raconter son le plus proche que vous pouvez obtenir sans post-élagage.

    InformationsquelleAutor James
  4. 0

    Ma réponse à "David Dale"'s réponse est supprimé,
    Je dois dire que,
    la méthode proposée par "David Dale" n'est Pas parfait,car le paramètre suivant de la sklearn modèle ne sera pas changé de façon synchrone après avoir été taillés:

    ` 

    model.tree_.impurity,
model.tree_.value,
model.tree_.children_left,
model.tree_.children_right

    `
    et lorsque vous souhaitez effectuer des CCP(coût de la complexité de la taille)de l'Algorithme sur sklearn PANIER modèle,

    vous ne pouvez PAS mettre en œuvre l'algorithme avec la méthode ci-dessus.

    supplément:
    J'ai réussi à mettre en œuvre le Coût de la complexité de l'élagage sur Sklearn du modèle, et voici le lien:
    https://github.com/appleyuchi/Decision_Tree_Prune

    InformationsquelleAutor appleyuchi