Als Richtlinie, für welche Algorithmen beim maschinellen Lernen verwendet werden soll, wurde Spickzettel zum Scikit-Lernalgorithmus eingeführt. Selbst wenn Sie nur die Klassifizierung darin betrachten, werden viele Algorithmen vorbereitet. In diesem Artikel werden wir sie vergleichen, damit Sie intuitiv verstehen können, wie jeder Klassifikator die Unterscheidungsgrenze bestimmt.

Was ich getan habe

Grundsätzlich lernen Klassifikatorvergleich in Beispiel von Scikit. auto_examples / klassifikation / plot_classifier_comparison.html) wird reproduziert --Vergleichen Sie die Klassifizierer in Scikit Learn anhand des generierten Datensatzes
Bestätigen Sie visuell die Identifikationsgrenze jedes Klassifikators

Hinweis

Der tatsächliche Datensatz sieht nicht immer wie in diesem Beispiel aus, dient also nur als Referenz. Insbesondere beim Umgang mit hochdimensionalen Daten können diese auch mit einem relativ einfachen Klassifikator wie Naive Bayes oder einer linearen Support-Vektor-Maschine identifiziert werden. Es ist verallgemeinerbar und oft nützlich als die Verwendung eines komplexen Klassifikators.

Art des zu verwendenden Klassifikators

Experimentiert mit 7 verschiedenen Klassifikatoren.

--k Nachbarschaftsmethode

Support Vector Machine (linear)
Support Vector Machine (Gaußscher Kernel) --Entscheidungsbaum
Zufälliger Wald --Ada Boost
Naive Bayes
Lineare Diskriminierungsanalyse
Sekundäre Diskriminierungsanalyse

Beispieldaten

Verwenden Sie die Datengenerierungsfunktion für das Klassifizierungsproblem von Sckit learn. Die folgenden drei Arten von Datensätzen mit unterschiedlichen Eigenschaften werden verwendet.

Zwei halbkreisförmige zweidimensionale Daten (linear nicht unterscheidbar)
Zweidimensionale Daten auf zwei konzentrischen Kreisen (linear nicht unterscheidbar)
Linear identifizierbarer Datensatz

Zwei halbkreisförmige zweidimensionale Daten (linear nicht identifizierbar)

Erstellt von make_moon. Die Farbe der Punkte in der Grafik gibt die Beschriftung an.

X, y = make_moons(noise = 0.05, random_state=0)

Zweidimensionale Daten auf zwei konzentrischen Kreisen (linear nicht unterscheidbar)

Erstellt von make_circle.

X, y = make_circles(noise = 0.02, random_state=0)

Linear identifizierbarer Datensatz

Generiert mit make_classification. Für make_classification ist dieser Kommentarartikel leicht zu verstehen. Vielen Dank.

Beispieldatengenerierung mit scicit-learn

Im folgenden Beispiel werden 100 Eingabedatensätze X mit zweidimensionalen Merkmalsmengen und 100 Etikettendatensätze y mit zwei Attributen erzeugt.

X, y = make_classification(n_features=2, n_redundant=0, n_informative=2,
                           random_state=5, n_clusters_per_class=1, n_samples=100, n_classes=2)

Ergebnis

Hier ist das Ausgabeergebnis. Die Spalte ganz links zeigt die Originaldaten, und die zweite und die folgenden Spalten von links zeigen die Unterscheidungsgrenzen mit verschiedenen Klassifizierern. Bei Verwendung eines halbkreisförmigen Datensatzes in der oberen Reihe, eines konzentrischen Kreisdatensatzes in der mittleren Reihe und eines linear trennbaren Datensatzes in der unteren Reihe. Die unten rechts in jedem Diagramm angezeigten Zahlen sind Bewertungswerte, die die Genauigkeit des Modells angeben. Sie können die Merkmale zum Zeichnen der Identifikationsgrenze für jeden Klassifikator verstehen.

(Referenzcode

Mit Ausnahme des Hinzufügens von Kommentaren auf Japanisch entspricht dies im Wesentlichen der Quelle Klassifikatorvergleich.

# -*- coding: utf-8 -*-
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
from matplotlib.colors import ListedColormap
from sklearn.cross_validation import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_moons, make_circles, make_classification
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
h = .02  # step size in the mesh

names = ["Nearest Neighbors", "Linear SVM", "RBF SVM", "Decision Tree",
         "Random Forest", "AdaBoost", "Naive Bayes", "Linear Discriminant Analysis",
         "Quadratic Discriminant Analysis"]
classifiers = [
    KNeighborsClassifier(3),
    SVC(kernel="linear", C=0.025),
    SVC(gamma=2, C=1),
    DecisionTreeClassifier(max_depth=5),
    RandomForestClassifier(max_depth=5, n_estimators=10, max_features=1),
    AdaBoostClassifier(),
    GaussianNB(),
    LinearDiscriminantAnalysis(),
    QuadraticDiscriminantAnalysis()]


#Generieren Sie Daten für ein zufälliges Zwei-Klassen-Identifikationsproblem
#Generieren Sie jeweils 100 Stichproben der 2D-Eingabedaten X und 2 Klassen von Etikettendaten y
X, y = make_classification(n_features=2, n_samples=100, n_redundant=0, n_informative=2,
                           random_state=1, n_clusters_per_class=1, n_classes=2)
rng = np.random.RandomState(0) #Zufällige Generatorklasse, Zahlen sind Samen, also ist alles in Ordnung
X += 2 * rng.uniform(size=X.shape) #Verarbeiten Sie die Originaldaten
linearly_separable = (X, y) #Linear identifizierbarer Datensatz

datasets = [make_moons(noise=0.25, random_state=0),
            make_circles(noise=0.2, factor=0.6, random_state=1),
            linearly_separable
            ]

figure = plt.figure(figsize=(27, 9))
i = 1
#Schleife mit 3 verschiedenen Datensätzen
for ds in datasets:
    #Datensatzpartitionierung für Datenvorverarbeitung, Schulung und Test
    X, y = ds
    X = StandardScaler().fit_transform(X) #Daten normalisieren
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.4)

    x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5
    y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5
    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                         np.arange(y_min, y_max, h))

    #Zeichnen Sie nur den Datensatz
    cm = plt.cm.RdBu
    cm_bright = ListedColormap(['#FF0000', '#0000FF'])
    ax = plt.subplot(len(datasets), len(classifiers) + 1, i)
    ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright) #Für das Training
    ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright, alpha=0.6) #Helle Farben zum Testen
    ax.set_xlim(xx.min(), xx.max())
    ax.set_ylim(yy.min(), yy.max())
    ax.set_xticks(())
    ax.set_yticks(())
    i += 1

    #Schleife mit Klassifikator
    for name, clf in zip(names, classifiers):
        ax = plt.subplot(len(datasets), len(classifiers) + 1, i)
        clf.fit(X_train, y_train)
        score = clf.score(X_test, y_test)

        #Berechnen Sie Schätzungen an jedem Punkt im Raster, um die Entscheidungsgrenzen zu zeichnen.
        if hasattr(clf, "decision_function"):
            Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()]) #Entfernung von der Entscheidungsgrenze
        else:
            Z = clf.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:, 1] #Wahrscheinlichkeit

        #Farbdiagramm
        Z = Z.reshape(xx.shape)
        ax.contourf(xx, yy, Z, cmap=cm, alpha=.8) #Rasterdaten
        ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright) #Trainingsdatenpunkte
        ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright, alpha=0.6) #Datenpunkte testen

        ax.set_xlim(xx.min(), xx.max())
        ax.set_ylim(yy.min(), yy.max())
        ax.set_xticks(())
        ax.set_yticks(())
        ax.set_title(name)
        ax.text(xx.max() - .3, yy.min() + .3, ('%.2f' % score).lstrip('0'),
                size=15, horizontalalignment='right')
        i += 1

figure.subplots_adjust(left=.02, right=.98)
plt.show()

[PYTHON] Scikit lernen verschiedene Klassifikatoren