[PYTHON] Ich habe versucht, den entscheidenden Baum (CART) zu verstehen, um ihn sorgfältig zu klassifizieren
Einführung
Bisher haben wir die logistische Regression zusammengefasst, unterstützen Vektormaschinen, neuronale Netze usw. Dieses Mal werde ich die grundlegenden Entscheidungsbäume wie XGBoost, LightGBM und Random Forest zusammenfassen.
Was ist ein Entscheidungsbaum?
Ein Entscheidungsbaum ist ein Algorithmus, der "Daten Schritt für Schritt trennt und baumartige Analyseergebnisse ausgibt".
Die Vorteile einer Analyse mit diesem Entscheidungsbaum sind:
- Leicht zu verstehen (die Basis der Klassifizierung kann visualisiert werden)
- Gilt sowohl für die Klassifizierung als auch für die Regression
- Kann eine Vielzahl von Problemen bewältigen
Es gibt Funktionen wie. Insbesondere finde ich den ersten Vorteil großartig. Andere Klassifizierer (Support-Vektor-Maschinen, neuronale Netze usw.) sind sehr kompliziert und in den darin durchgeführten Berechnungen Black-Box-fähig, sodass es für jeden, der mit dem Inhalt des Modells vertraut ist, schwierig ist, den Inhalt zu verstehen. Da ist ein Gesicht. Andererseits ist der Entscheidungsbaum ein leicht verständliches Merkmal, da die Gründe für die Teilung klar sind, wie in der obigen Abbildung gezeigt. Ich denke das ist ** leicht zu verstehen ** ein großer Vorteil. Dies liegt daran, dass ich nicht denke, dass es eine gute Einstellung für einen Techniker für eine Person ist, die ein Modell verwendet, um Ergebnisse mit etwas zu erzielen, das sie nicht verstehen **.
Dieser Entscheidungsbaum ist ein Algorithmus, der sowohl auf die Klassifizierung als auch auf die Regression angewendet werden kann. Dieses Mal möchte ich jedoch die Klassifizierung zusammenfassen. Darüber hinaus verfügt der Entscheidungsbaum über einen Algorithmus namens CART und C4.5. Diesmal geht es um CART.
Wie man die Kriterien für die Teilung entscheidet
Teilen Sie so, dass die Elemente nach der Teilung (zu teilende Daten) für jedes Element gelten, das Sie teilen möchten (= die Reinheit nach der Teilung ist das Minimum). Unreinheit ist ein Indikator dafür, wie verschiedene Klassen von Elementen miteinander vermischt werden.
Ich möchte es kurz mit einem Beispiel betrachten. Ich möchte die make_blobs () Methode von scikit learn laden und erstellen, die mir eine Sprühprobe gibt.
RF.ipynb
#Imports
%matplotlib inline
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn
from sklearn.datasets import make_blobs
X, y = make_blobs(n_samples=500, centers=4,
random_state=8, cluster_std=2.2)
#Scatter plot the points
plt.figure(figsize=(10,10))
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='jet')
Das ursprüngliche Streudiagramm ist hier.
Lassen Sie uns nun darüber nachdenken, wie Sie dieses Streudiagramm teilen können.
Aufgrund der Trennlinie links das Element $ [2], gegenüber der Gruppe mit vielen Elementen $ [0], [1] $ (umgekehrt ohne $ [2], [3] $) Sie können sehen, dass es in Gruppen unterteilt werden kann, die viel [3] $ enthalten (umgekehrt sind $ [0] und [1] $ nicht enthalten). Diese Art der Teilung ist eine Teilungsmethode mit geringerer Reinheit. Andererseits können Sie im Fall der Trennlinie rechts sehen, dass die Elemente von $ [0] bis [3] $ nach dem Teilen in der Gruppe gemischt werden. Dies wird als mit vielen Verunreinigungen bezeichnet. Suchen Sie die Trennlinie wie links gezeigt und klassifizieren Sie sie mehrmals (= Tiefe des Entscheidungsbaums genannt), um den Zweck zu klassifizieren.
Wie man Reinheit findet
Lassen Sie uns nun zusammenfassen, wie diese Unreinheit ausgedrückt werden kann. Dieses Mal konzentrieren wir uns auf Ginis Diversity Index $. Die wörtliche Übersetzung ist der Gini Diversity Index. Ich denke, Sie können die Bedeutung auf Japanisch verstehen, aber es scheint, dass es oft als unrein bezeichnet wird.
Betrachten Sie eine Hierarchie (= Knoten) $ t $ mit einem Entscheidungsbaum. Ein Knoten ist eine Gruppe, nachdem er aufgeteilt wurde. Betrachten Sie dann den Fall, in dem sich $ n $ Samples im Knoten und $ c $ Klassen im Knoten befinden. Unter der Annahme, dass die Anzahl der zur Klasse $ i $ gehörenden Abtastwerte im Knoten $ t $ $ n_i $ ist, kann zu diesem Zeitpunkt das Verhältnis der Abtastwerte, die zur Klasse $ i $ p (i | t) $ gehören, wie folgt ausgedrückt werden. Ich kann es schaffen
Zu diesem Zeitpunkt kann Gini Impure $ I_G (t) $ wie folgt ausgedrückt werden.
Die Summe von $ p (i | t) ^ 2 $ erhöht sich, wenn eine gute Division vorgenommen wird. Daher wird $ I_G (t) $ kleiner. Mit diesem Bewertungsindex werden wir einen guten Klassifikator erstellen.
Angeordnet, damit das Diagramm besser sichtbar ist
Färben Sie jede Klasse aus, um das Verständnis zu erleichtern.
RF.ipynb
def visualize_tree(classifier, X, y, boundaries=True,xlim=None, ylim=None):
'''
Visualisieren Sie den Entscheidungsbaum.
INPUTS:Klassifizierungsmodell, X, y, optional x/y limits.
OUTPUTS:Visualisierung von Entscheidungsbäumen mit Meshgrid
'''
#Erstellen eines Modells mit fit
classifier.fit(X, y)
#Automatische Einstellung der Achse
if xlim is None:
xlim = (X[:, 0].min() - 0.1, X[:, 0].max() + 0.1)
if ylim is None:
ylim = (X[:, 1].min() - 0.1, X[:, 1].max() + 0.1)
x_min, x_max = xlim
y_min, y_max = ylim
#Erstellen Sie ein Netzgitter.
xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100),
np.linspace(y_min, y_max, 100))
#Speichern Sie Klassifikatorvorhersagen als Z.
Z = classifier.predict(np.c_[xx.ravel(), yy.ravel()])
#Verwenden Sie Meshgrid, um es zu formen.
Z = Z.reshape(xx.shape)
#Färben Sie jede Kategorie.
plt.figure(figsize=(10,10))
plt.pcolormesh(xx, yy, Z, alpha=0.2, cmap='jet')
#Es werden auch Trainingsdaten gezeichnet.
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='jet')
plt.xlim(x_min, x_max)
plt.ylim(y_min, y_max)
def plot_boundaries(i, xlim, ylim):
'''
Zeichne einen Rand.
'''
if i < 0:
return
tree = classifier.tree_
#Rufen Sie rekursiv auf, um die Grenzen zu ziehen.
if tree.feature[i] == 0:
plt.plot([tree.threshold[i], tree.threshold[i]], ylim, '-k')
plot_boundaries(tree.children_left[i],
[xlim[0], tree.threshold[i]], ylim)
plot_boundaries(tree.children_right[i],
[tree.threshold[i], xlim[1]], ylim)
elif tree.feature[i] == 1:
plt.plot(xlim, [tree.threshold[i], tree.threshold[i]], '-k')
plot_boundaries(tree.children_left[i], xlim,
[ylim[0], tree.threshold[i]])
plot_boundaries(tree.children_right[i], xlim,
[tree.threshold[i], ylim[1]])
if boundaries:
plot_boundaries(0, plt.xlim(), plt.ylim())
Versuchen Sie, nach Entscheidungsbaum zu klassifizieren
RF.ipynb
from sklearn.tree import DecisionTreeClassifier
clf = DecisionTreeClassifier(criterion='entropy',max_depth=2,random_state=0)
visualize_tree(clf,X,y)
Ich konnte es in ein gutes Gefühl aufteilen. Bestimmen Sie oben die Tiefe des ermittelten Baums mit "max_depth". Das Erhöhen (= Vertiefen) des Werts dieser "max_depth" führt zu Überlernen. Versuchen Sie es mit max_depth = 6.
Sie können sehen, dass es überteilt ist (insbesondere die rote Klasse). Der Punkt ist, dass Sie diese Tiefe selbst anpassen müssen.
Visualisierung der Basis des Entscheidungsbaums
Übrigens ist das Bild des Entscheidungsbaums bei Überprüfung in Tiefe 2 unten dargestellt.
Die numerischen Werte und die Gini-Unreinheit, die als Kriterien für die Klassifizierung dienen, werden aufgelistet. value ist die Anzahl der Elemente in den Klassen [0] bis [3].
So geben Sie ein Entscheidungsbaumbild aus
Übrigens ist es ein schnelles Image, aber es ist notwendig, die Bibliothek zu importieren und die Software zu installieren.
- Installieren Sie pydotplus
- Installieren Sie graphviz
- Durch den Weg
Die oben genannten drei Aktionen waren notwendig, um zu retten.
- Installieren Sie pydotplus
Dies ist eine Bibliothek, die den durch den Entscheidungsbaum geteilten Inhalt in einer ".dot" -Datei speichert.
console
pip install pydotplus
Wie bei jeder anderen Bibliothek können Sie sie mit pip installieren.
- Installieren Sie graphviz
Ich habe das Installationsprogramm (graphviz-2.38.msi) von dieser URL heruntergeladen.
https://graphviz.gitlab.io/_pages/Download/Download_windows.html
Wenn der Download abgeschlossen ist, doppelklicken Sie auf "graphviz-2.38.msi", um ihn zu installieren. Installieren Sie außerdem graph viz auf pip.
- Übergeben Sie den Pfad
Übergeben Sie dann "Pfad", um es als PDF zu erstellen. Geben Sie den Ordner an, in dem sich dot.exe befindet. Ich habe die Methode bereits zusammengefasst, siehe hier.
https://qiita.com/Fumio-eisan/items/340de9fe220a90607013
Schließlich müssen Sie die Syntax in graphviz.py wie folgt umschreiben:
Zu diesem Zeitpunkt kann der Entscheidungsbaum in .dot und pdf konvertiert werden.
RF.ipynb
import pydotplus
import os
from graphviz import Source
from sklearn.tree import export_graphviz
export_graphviz(
clf,
out_file=os.path.join("text_classification.dot"),
class_names=['1', '2','3','4'],
rounded=True,
filled=True
)
with open("random.dot", 'w') as f:
f = export_graphviz(clf, out_file=f)
data = export_graphviz(clf, out_file=None)
graph = pydotplus.graph_from_dot_data(data)
graph.write_pdf("random.pdf")
Ich habe auf diese Seite verwiesen.
GraphViz-Fehlerbehandlung (ausführbare Dateien von GraphViz nicht gefunden) https://niwakomablog.com/graphviz-error-handling/
Am Ende
Dieses Mal haben wir den Inhalt und die Implementierung der Klassifizierung von Entscheidungsbäumen zusammengefasst. Die Idee ist leicht zu verstehen und leicht umzusetzen. Am Ende hatte ich jedoch das Gefühl, dass es eine kleine Hürde war, den Entscheidungsbaum in ein PDF umzuwandeln. Als nächstes möchte ich zurückkehren.
Das vollständige Programm finden Sie hier. https://github.com/Fumio-eisan/RF_20200423