Apprentissage automatique facile à comprendre - Python implémente manuellement un arbre de décision simple

Cet article a participé à l'événement "Newcomer Creation Ceremony" pour commencer la route vers la création d'or.

introduction

L'arbre de décision est un modèle d'algorithme courant dans l'apprentissage automatique. Cet article analysera le processus d'établissement d'un arbre de décision à partir d'un simple problème de classification à intervalles discrets et utilisera python pour implémenter manuellement un arbre de décision simple.

Contexte

Cet exemple prend l'interview comme arrière-plan et sélectionne trois indicateurs : s'il s'agit du 985, l'éducation et le langage de programmation pour juger s'il peut être admis.

Processus de construction de l'arbre de décision

1) Ajouter tous les indicateurs à la liste des indicateurs

2) Calculez l'entropie de chaque index dans la liste d'index et divisez-la en fonction de l'index avec la plus petite entropie

3) S'il peut être divisé avec succès, obtenez le résultat directement, sinon supprimez l'indicateur de la liste des indicateurs et effectuez l'étape 2) et ajoutez le résultat à l'arbre de décision

Note : Dans cet article, un dictionnaire est utilisé pour représenter la structure de l'arbre (arbre multi-fork)

Forfait Dépendance

import numpy as np
from collections import Counter
from math import log2
复制代码

Calculer la perte

Entropie des informations

def entropy(y_label):
    counter = Counter(y_label)
    ent = 0.0
    for num in counter.values():
        p = num / len(y_label)
        ent += -p * log2(p)
    return ent
复制代码

En plus d'utiliser l'entropie de l'information ici, le coefficient de Gini peut également être utilisé à la place

Coefficient de Gini

def geni(y_label):
    counter = Counter(y_label)
    g = 1
    for num in counter.values():
        p = num / len(y_label)
        g -= p * p
    return g
复制代码

Définir un arbre de décision

class DecisionTree:
    def __init__(self):
        self.tree = {}
    #训练决策树
    def fit(self,X,y):
        cols = list(range(X.shape[1]))
        #对X得每一列数据，计算分割后得信息熵
        self.tree = self._genTree(cols, X, y)
    #递归生成决策树

    def _genTree(self, cols, X, y):
        # 计算最小信息熵得特征
        imin = cols[0] # 最下熵得列
        emin = 100 # 最小熵值
        for i in cols:
            coli = X[:,i]#拿到第i个特征数据
            enti = sum([entropy(y[coli==d]) for d in set(coli)]) # （也可以使用基尼系数计算，下同）
            if enti < emin:
                imin = i
                emin = enti
        #根据最小熵特征有几个值，就生成几个新的子树分支   
        newtree={}
        mincol = X[:,imin]
        cols.remove(imin)
        #针对这个特征得每个值，进一步划分树
        for d in set(mincol):
            entd = entropy(y[mincol==d])  # 计算信息熵
            if entd <1e-10:#已经完全分开
                newtree[d] = y[mincol==d][0]
            else:#还需要进一步细分
                newtree[d] = self._genTree(cols.copy(), X[mincol==d, :], y[mincol==d])
        return {imin: newtree}#将列号作为索引，返回新生成的树

    #预测新样本
    def predict(self, X):
        X = X.tolist()
        y = [None for i in range(len(X))]
        for i in range(len(X)):
            predictDict = self.tree
            while predictDict != 'Yes' and predictDict != 'No':
                col = list(predictDict.keys())[0]
                predictDict = predictDict[col]
                predictDict = predictDict[X[i][col]]
            else:
                y[i] = predictDict
        return y
复制代码

test

X=np.array([['Yes985','本科','C++'],
            ['Yes985','本科','Java'],
            ['No985' ,'硕士','Java'],
            ['No985' ,'硕士','C++'],
            ['Yes985','本科','Java'],
            ['No985' ,'硕士','C++'],
            ['Yes985','硕士','Java'],
            ['Yes985','博士','C++'],
            ['No985' ,'博士','Java'],
            ['No985' ,'本科','Java']])
y=np.array(['No','Yes','Yes','No','Yes','No','Yes','Yes','Yes','No'])

dt = DecisionTree()
dt.fit(X, y)
print(dt.tree)
print(dt.predict(X))
复制代码

On peut voir que les résultats du test sur les données d'entraînement sont très bons.Vous pouvez créer des données pour les tester vous-même.

explication du code

fonction d'entropie : utilisée pour calculer l'entropie de l'information, où Counter est utilisé pour compter le nombre de catégories différentes, le nombre de chaque catégorie est divisé par le nombre total pour obtenir la probabilité, puis l'entropie de l'information est calculée par la probabilité. DecisonTree.fit : pour la formation du modèle, le nœud racine de l'arbre est établi dans cette fonction. DecisonTree._genTree : Construire un arbre. Le processus de construction est tel que décrit ci-dessus. DecisonTree.predict : Faire des prédictions. Dans l'arbre de décision, seul le dernier résultat de prédiction est un nœud feuille. Processus de prédiction : 1) Sélectionner l'indicateur 2) En fonction de l'indicateur sélectionné, établir et sélectionner un nouveau sous-nœud en fonction de la valeur correspondant au sous-nœud de l'indicateur et des données 3) Lorsque le sous-nœud est un indicateur, utilisez l'indicateur pour répéter le processus 2), lorsque le sous-nœud est un indicateur, utilisez l'indicateur pour répéter le processus 2) La prédiction se termine lorsque le nœud est le résultat de la prédiction