J'ai présenté la feuille de triche de l'algorithme scikit learn comme guide pour savoir quel algorithme doit être utilisé dans l'apprentissage automatique. Même si vous ne regardez que la classification, de nombreux algorithmes sont préparés. Dans cet article, nous les comparerons afin que vous puissiez comprendre intuitivement comment chaque classificateur détermine la frontière de discrimination.

Ce que j'ai fait

En gros, Comparaison des classificateurs dans Exemple de Scikit apprennent. auto_examples / classification / plot_classifier_comparison.html) est reproduit --Comparez les classificateurs dans Scikit learn en utilisant l'ensemble de données généré
Confirmer visuellement la limite d'identification de chaque classificateur

Mise en garde

L'ensemble de données réel ne ressemble pas toujours à cet exemple, il est donc à titre indicatif uniquement. Surtout lorsqu'il s'agit de données de grande dimension, elles peuvent être identifiées même avec un classificateur relativement simple tel que Naive Bayes ou une machine à vecteur de support linéaire. Il est plus généralisable et souvent utile que l'utilisation d'un classificateur complexe.

Type de classificateur à utiliser

Expérimenté avec 7 classificateurs différents.

--k méthode de voisinage -Machine à vecteurs de soutien (linéaire) -Support Vector Machine (noyau gaussien) --Arbre de décision --Forêt aléatoire --Ada Boost --Naive Bayes --Analyse de discrimination linéaire --Analyse de discrimination secondaire

Exemple de données

Utilisez la fonction de génération de données pour le problème de classification de Sckit learn. Les trois types d'ensembles de données suivants avec des propriétés différentes sont utilisés.

Deux données bidimensionnelles semi-circulaires (linéairement indiscernables)
Données bidimensionnelles sur deux cercles concentriques (linéairement indiscernables)
Ensemble de données linéairement identifiables

Deux données bidimensionnelles semi-circulaires (linéairement non identifiables)

Généré par make_moon. La couleur des points sur le graphique indique l'étiquette.

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

Données bidimensionnelles sur deux cercles concentriques (linéairement indiscernables)

Généré par make_circle.

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

Ensemble de données linéairement identifiable

Généré avec make_classification. Pour make_classification, cet article de commentaire est facile à comprendre. Merci beaucoup.

Exemple de génération de données à l'aide de scicit-learn

Dans l'exemple suivant, 100 ensembles de données d'entrée X ayant des quantités de caractéristiques bidimensionnelles et 100 ensembles de données d'étiquette y avec deux attributs sont générés.

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)

résultat

Voici le résultat de la sortie. La colonne la plus à gauche montre les données d'origine, et la deuxième colonne et les suivantes à gauche montrent les limites de discrimination avec différents classificateurs. Lors de l'utilisation d'un ensemble de données semi-circulaire dans la ligne supérieure, d'un ensemble de données de cercle concentrique dans la ligne du milieu et d'un ensemble de données séparables linéairement dans la ligne inférieure. Les nombres affichés en bas à droite de chaque graphique sont des valeurs d'évaluation qui indiquent la précision du modèle. Vous pouvez comprendre les caractéristiques de la façon de dessiner la limite d'identification pour chaque classificateur.

(Code de référence

Sauf pour l'ajout de commentaires en japonais, c'est fondamentalement le même que la source Comparaison des classificateurs.

# -*- 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()]


#Générer des données pour un problème d'identification aléatoire à deux classes
#Générer 100 échantillons de chacune des données d'entrée 2D X et 2 classes de données d'étiquette 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) #Classe de générateur aléatoire, les nombres sont des graines, donc tout va bien
X += 2 * rng.uniform(size=X.shape) #Traiter les données d'origine
linearly_separable = (X, y) #Ensemble de données linéairement identifiable

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
#Boucle avec 3 jeux de données différents
for ds in datasets:
    #Partitionnement de l'ensemble de données pour le prétraitement, la formation et le test des données
    X, y = ds
    X = StandardScaler().fit_transform(X) #Normaliser les données
    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))

    #Tracer uniquement le jeu de données
    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) #Pour s'entraîner
    ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright, alpha=0.6) #Couleurs vives pour les tests
    ax.set_xlim(xx.min(), xx.max())
    ax.set_ylim(yy.min(), yy.max())
    ax.set_xticks(())
    ax.set_yticks(())
    i += 1

    #Boucle avec classificateur
    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)

        #Calculez des estimations à chaque point de la grille pour tracer les limites de décision.
        if hasattr(clf, "decision_function"):
            Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()]) #Distance de la frontière de décision
        else:
            Z = clf.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:, 1] #probabilité

        #Tracé de couleur
        Z = Z.reshape(xx.shape)
        ax.contourf(xx, yy, Z, cmap=cm, alpha=.8) #Données de grille
        ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright) #Points de données d'entraînement
        ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright, alpha=0.6) #Points de données de test

        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 learn Divers classificateurs