Créez un arbre de décision à partir de 0 avec Python et comprenez-le (4. Structure des données)

** Créer et comprendre des arbres de décision à partir de zéro en Python ** 1. Présentation-2. Bases du programme Python-3. Données Bibliothèque d'analyse Pandas --4 Structure des données

Pour l'apprentissage de l'IA (machine learning) et de l'exploration de données, nous comprendrons en créant un arbre de décision à partir de zéro en Python.

4.1 Structure des données

La structure des données est une représentation de la façon dont les données individuelles sont organisées.

Tableau

Les données individuelles sont alignées sur une ligne. Pour identifier un élément de données, vous avez besoin d'un identifiant, par exemple, quel nombre de données.

#Exemple d'implémentation de tableau en python
a = [2,6,4,5,1,8]

Table, tableau à deux dimensions

#Exemple d'implémentation de table en python
a = [
    [2,6,4,5,1,8],
    [4,4,1,3,4,2],
    [5,3,6,6,5,3],
    [7,8,0,9,5,3],
]

Arbre, structure arborescente

C'est une structure de données qui relie des données individuelles à une ligne. Cependant, la ligne ne circule pas, par exemple, lorsque l'on considère l'itinéraire d'une donnée à une autre, celui avec un itinéraire est les données de l'arborescence. Il est souvent illustré par un arbre qui s'étend de haut en bas, comme illustré ci-dessous. Les lignes sont appelées bords et branches, les données sont appelées nœuds, les données avec des lignes en dessous sont appelées troncs et nœuds, les données sans lignes sont appelées feuilles et feuilles, et les données supérieures sont appelées nœuds racines et racines. Je t'appellerai. La ligne peut être à sens unique avec une flèche.

#Exemple d'implémentation d'arborescence en python Contient une liste de nœuds enfants.
# [valeur,Tableau de la liste des nœuds enfants]Par exemple, l'arborescence ci-dessus est implémentée de haut en bas et de gauche à droite comme suit.
#En dehors de cette méthode d'implémentation, il existe des méthodes telles que l'utilisation d'une classe et la détention d'un nœud parent.
tree = \
[2,[
    [6,[]],
    [4,[
        [5,[
            [6,[]],
        ]],
        [8,[]],
        [1,[]],
    ]],
]]

#Fonction d'affichage de l'arborescence
def tstr(node,indent=""):
    print(indent+str(node[0]))
    for c in node[1]: #Boucle sur les nœuds enfants
        tstr(c,indent+"+-")
tstr(tree)
#production
# 2
# +-6
# +-4
# +-+-5
# +-+-+-6
# +-+-8
# +-+-1

#Si vous ne voulez pas faire l'arbre entier à la fois, mais un par un
#Créez tous les nœuds feuilles qui n'ont pas de nœuds enfants. Le nom de la variable est le numéro de la ligne (colonne) et de la gauche.
n10 = [6,[]]
n21 = [8,[]]
n22 = [1,[]]
n40 = [6,[]]
#Créez tous les nœuds enfants dans l'ordre à partir du nœud généré.
n20 = [5,[n40]]
n11 = [4,[n20,n21,n22]]
n00 = [2,[n10,n11]]

#Afficher l'arborescence, afficher le nœud spécifié en tant que nœud racine.
tstr(n11)
#production
# 4
# +-5
# +-+-6
# +-8
# +-1

Réseau, graphique

#Exemple d'implémentation de réseau en python
import pandas as pd

#On suppose que le nom du nœud et la valeur correspondent.
#Si le nom et la valeur ne correspondent pas, vous avez besoin de données pour soustraire la valeur du nom.
nodes = [2,6,4,5,8,1]
#Définissez l'état de connexion des nœuds sous la forme d'une matrice. Nœud 2(La première ligne)À partir du nœud 6(2e ligne)S'il y a un bord
#La valeur de 1 ligne et 2 colonnes de la matrice est 1 et 0 s'il n'y a pas d'arête. Cette matrice est appelée une matrice adjacente.
df = pd.DataFrame(
[
    # 2,6,4,5,8,Y a-t-il une connexion à un nœud?
    [ 0,1,1,0,0,0], #À partir de 2 nœuds
    [ 1,0,0,1,0,0], #À partir de 6 nœuds
    [ 1,0,0,1,1,1], #À partir de 4 nœuds
    [ 0,1,1,0,0,0], #À partir de 5 nœuds
    [ 0,0,1,0,0,0], #À partir de 8 nœuds
    [ 0,0,1,0,0,0], #À partir d'un nœud
],columns=nodes,index=nodes)
print(df)
#production
#    2  6  4  5  8  1
# 2  0  1  1  0  0  0
# 6  1  0  0  1  0  0
# 4  1  0  0  1  1  1
# 5  0  1  1  0  0  0
# 8  0  0  1  0  0  0
# 1  0  0  1  0  0  0

#Le réseau est dessiné par matplotlib et une bibliothèque appelée networkx.
import matplotlib.pyplot as plt
import networkx as nx
plt.figure(figsize=(4,4))
plt.axis("off")
nx.draw_networkx(nx.from_pandas_adjacency(df))
plt.show()

Exemple de sortie réseau

4.2 Exemple d'implémentation python de l'arbre de décision

L'arbre de décision, comme son nom l'indique, peut être représenté par une structure arborescente. Les données détenues par le nœud comprennent les règles de branchement et la liste des données pouvant atteindre ce nœud dans l'arbre de décision, en plus de la liste des nœuds enfants qui ont une structure arborescente.

Placez un nœud vide sur le nœud racine et associez toutes les données, comme indiqué ci-dessous. Le numéro [...] attaché au nœud représente le numéro de données des données d'origine à partir desquelles cet arbre de décision est créé. Et à partir du nœud racine, seules les données qui remplissent les conditions des nœuds enfants peuvent être exprimées comme descendant dans l'arborescence. Les nœuds de l'arbre de décision qui vont au golf et ne vont pas au golf peuvent être trouvés en regardant les données associées au nœud.

L'implémentation python est, par exemple: Un nœud est un tableau associatif, nom est une représentation de caractère de la condition de ce nœud, df est les données associées à ce nœud et bords est une liste de nœuds enfants.

#Données de l'arborescence
tree = {
    # name:Ce nœud(tige)Le nom de
    "name":"decision tree "+df0.columns[-1]+" "+str(cstr(df0.iloc[:,-1])),
    # df:Données associées à ce nœud
    "df":df0,
    # edges:Edge sortant de ce nœud(branche)Dans la liste, si le nœud feuille n'a pas d'arête en dessous, ce sera un tableau vide.
    "edges":[],
}

La fonction tstr qui caractérise cette arborescence ressemble à ceci:

#Expression Lambda pour la distribution de valeur, l'argument est pandas.Series, la valeur de retour est un tableau contenant le numéro de chaque valeur
#Entrée s à valeur_counts()Obtenez la fréquence de chaque valeur avec et des éléments de boucle de données de type dictionnaire()Appeler.
#trié trie par ordre croissant de fréquence afin que le résultat de sortie ne change pas à chaque exécution.
#Et l'élément est la clé(k)Et valeur(v)Générez un tableau qui est une chaîne de caractères de.
cstr = lambda s:[k+":"+str(v) for k,v in sorted(s.value_counts().items())]

#Méthode pour convertir l'arbre en caractères, l'argument est l'arbre:Structure de données arborescente, retrait:Retrait sur les nœuds enfants,
#La valeur de retour est une représentation de caractère de l'arbre. Cette méthode est appelée récursivement pour convertir tout ce qui se trouve dans l'arborescence en caractères.
def tstr(tree,indent=""):
    #Créez une représentation de caractère pour ce nœud. Si ce nœud est un nœud feuille(Le nombre d'éléments dans le tableau d'arêtes est de 0)À
    #Caractériser la distribution de fréquence dans la dernière colonne des données df associées à l'arbre.
    s = indent+tree["name"]+str(cstr(tree["df"].iloc[:,-1]) if len(tree["edges"])==0 else "")+"\n"
    #Boucle sur tous les bords de ce nœud.
    for e in tree["edges"]:
        #Ajoutez la représentation de caractère du nœud enfant à la représentation de caractère de ce nœud.
        #Pour le retrait, ajoutez plus de caractères au retrait de ce nœud.
        s += tstr(e,indent+"  ")
        pass
    return s

L'arbre de décision transcrit par cette fonction tstr ressemble à ceci: Le nœud racine affiche le caractère (golf d'arbre de décision) qui a été défini lorsque la variable d'arbre a été créée pour la première fois et la distribution de fréquence d'aller / ne pas jouer au golf pour toutes les données. Dans chaque nœud en dessous, les règles utilisées pour le branchement et, dans le cas des nœuds feuilles, la distribution de fréquence d'aller / ne pas aller au golf dans les données associées à ce nœud (par exemple ['○: 2']) Est affiché.

golf d'arbre de décision['×:5', '○:9']
Météo=Bien
Humidité=d'habitude['○:2']
Humidité=Haute['×:3']
Météo=Nuageux['○:4']
Météo=pluie
Vent=Oui['×:2']
Vent=Rien['○:3']