[Python] Persönliches Tutorial zum Entscheidungsbaum

Es wird als Einmachblatt verwendet.

Was ist ein Entscheidungsbaum?

Der Entscheidungsbaum ist ein Modell für maschinelles Lernen, das häufig bei der Klassifizierung und Regressionsvorhersage verwendet wird. Es hat eine ** hierarchische Struktur **, die aus Fragen besteht, die mit Ja / Nein beantwortet werden können. Im Entscheidungsbaum können Sie sehen, wie stark sich jede erklärende Variable auf die Zielvariable auswirkt. Sie verzweigt sich durch Wiederholen der Division, aber die zuerst geteilte Variable hat mehr Einfluss. Es kann als groß angesehen werden.

Dieser Klassifizierer kann als Klassifizierungsmodell ** ausgedrückt werden, das 4 Datenklassen durch drei Merkmalsgrößen unterscheidet **. Unter Verwendung eines Algorithmus für maschinelles Lernen kann ein solches Modell Trainingsdaten lernen und tatsächlich einen Baum zeichnen, wie oben beschrieben.

Merkmale des Entscheidungsbaums

verdienen

• Relativ einfach zu interpretieren, da der Entscheidungsbaum die Ergebnisse ** visualisieren ** kann
• Nicht von unterschiedlichen Funktionsskalen betroffen, keine Vorverarbeitung wie Standardisierung erforderlich **

Fehler

• ** Starkes Vertrauen in Trainingsdaten ** Unabhängig davon, wie Sie die Parameter einstellen, erhalten Sie möglicherweise nicht die gewünschte Baumstruktur
• ** Leicht zu überlernen ** Neigt dazu, eine geringe Generalisierungsleistung zu haben

Bewertungsmethoden

Verwirrte Matrix

Die Verwirrungsmatrix ist eine Grundmatrix, wenn die Bewertung eines Klassifizierungsmodells berücksichtigt wird, und repräsentiert die Beziehung zwischen dem vorhergesagten Wert und dem beobachteten Wert des Modells. Insbesondere gibt es, wie in der folgenden Abbildung gezeigt, vier Kategorien: ** wahr positiv ** (wahr positiv), ** wahr negativ ** (wahr negativ), ** falsch positiv ** (falsch positiv), ** falsch Hat ein negatives ** (falsches Negativ).

Richtige Antwortrate (Genauigkeit)

Es ist das Verhältnis der Vorhersage zum Ganzen und kann wie folgt berechnet werden. $ Richtige Antwortrate = \ frac {TP + TN} {TP + FP + FN + TN} $

Präzision

Das Verhältnis der als positiv vorhergesagten Daten ist tatsächlich positiv und kann wie folgt berechnet werden. $ Anpassungsrate = \ frac {TP} {TP + FP} $

Erinnern

Es ist das Verhältnis von denen, die tatsächlich positiv sind, und denen, von denen vorhergesagt wird, dass sie positiv sind, und kann wie folgt berechnet werden. $ Rückrufrate = \ frac {TP} {TP + FN} $

In Python implementiert

• Annahme der Ausführung mit einem Jupyter-Notebook

Datensatz

Ein Datensatz, der die diagnostischen Daten für Brustkrebs von Scikit-Learn zusammenfasst. Es ist gutartig (1) und bösartig (0).

Bibliothek zu verwenden

[In]

#Bibliothek für die Datenverarbeitung
import pandas as pd
import numpy as np

#Bibliothek zur Datenvisualisierung
import matplotlib.pyplot as plt; plt.style.use('ggplot')
import matplotlib.gridspec as gridspec
import seaborn as sns
%matplotlib inline

#Bibliothek für maschinelles Lernen
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

Konstantes System

[In]

#Konstante
RESPONSE_VARIABLE = 'cancer' #Objektive Variable
TEST_SIZE = 0.2
RANDOM_STATE = 42

Daten lesen

[In]

#Daten lesen(scikit-Krebsdaten lernen)
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

#Zeige die ersten 5 Zeilen
cancer.head()

Grundlegende Tabellierung

[In]

#Überprüfen Sie die Statistiken
cancer.describe()

[In]

#Anzahl der objektiven Variablen
cancer[RESPONSE_VARIABLE].value_counts()

[Out]

1    357
0    212
Name: cancer, dtype: int64

[In]

#Bestätigung fehlender Werte
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

Datenaufteilung

[In]

#Unterteilt in Trainingsdaten und Testdaten
train, test = train_test_split(cancer, test_size=TEST_SIZE, random_state=RANDOM_STATE)

#Teilen Sie in erklärende Variablen und objektive Variablen
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()

Datenvisualisierung

[In]

#Visualisieren Sie die Verteilung der Zielvariablen für jedes Feature
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)

Merkmalsauswahl

Mit "RandomForestClassifier ()" von Scikit-learn ist es möglich, die "Wichtigkeit" jedes Feature-Betrags als "feature_importances_" zu bestätigen.

[In]

#Merkmalsauswahl
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]

#Ausgabefunktionen in absteigender Reihenfolge der Wichtigkeit
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 Ergebnisse der zufälligen Auswahl von Waldmerkmalen

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

[In]

#Holen Sie sich die Top 5 als 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]

#Konzentrieren Sie Trainings- und Testdaten nur auf die wichtigsten Funktionen
X_train = X_train[feature_list]
X_test = X_test[feature_list]

[In]

#Überprüfen Sie erneut die Verteilung der Zielvariablen
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)

Lernen / Vorhersage / Bewertung

[In]

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

[In]

#Vorausgesagt anhand der Funktionen von Trainingsdaten
y_pred = clf.predict(X_train)

[In]

def drawing_confusion_matrix(y: pd.Series, pre: np.ndarray) -> None:
    """
Eine Funktion, die eine Verwirrungsmatrix zeichnet
    
    @param y:Objektive Variable
    @param pre:Erwarteter Wert
    """
    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:
    """
Eine Funktion, die die richtige Antwortrate, Präzisionsrate und Rückrufrate berechnet und ausgibt.
    
    @param y:Objektive Variable
    @param pre:Erwarteter Wert
    """
    print('Richtige Antwortrate: {:.3f}'.format(metrics.accuracy_score(y, pre)))
    print('Compliance-Rate: {:.3f}'.format(metrics.precision_score(y, pre)))
    print('Erinnern: {:.3f}'.format(metrics.recall_score(y, pre)))

[In]

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

:[Out]
Richtige Antwortrate: 0.969
Compliance-Rate: 0.979
Erinnern: 0.972

163 in TP (oben links) ist die tatsächliche Anzahl der bösartigen, die das Modell als bösartig vorausgesagt hat. 9 in FP (unten rechts) ist eine Zahl, die als bösartig und nicht als tatsächlich bösartig vorhergesagt wird. Die FN (oben rechts) von 6 ist tatsächlich bösartig, wird jedoch als gutartig vorausgesagt.

[In]

#Vorhersage von Testdaten mit einem trainierten Modell
y_pred_test = clf.predict(X_test)

[In]

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

[Out]

Richtige Antwortrate: (TP + TN)/(TP + TN + FP + FN)
Richtige Antwortrate: 0.939
Compliance-Rate: TP/(TP + FP)
Compliance-Rate: 0.944
Erinnern: TP/(TP + FN)
Erinnern: 0.958