[Français] scikit-learn 0.18 Guide de l'utilisateur 1.12. Algorithme multi-classes et algorithme multi-étiquettes

google traduit http://scikit-learn.org/0.18/modules/multiclass.html [scikit-learn 0.18 Guide de l'utilisateur 1. Apprentissage supervisé](http://qiita.com/nazoking@github/items/267f2371757516f8c168#1-%E6%95%99%E5%B8%AB%E4%BB%98 À partir de% E3% 81% 8D% E5% AD% A6% E7% BF% 92)


1.12. Algorithme multi-classes et algorithme multi-étiquettes

** AVERTISSEMENT **: Tous les classificateurs scikit-learn fournissent une classification multiclasse prête à l'emploi. Vous n'avez pas besoin d'utiliser le module sklearn.multiclass sauf si vous avez essayé différentes stratégies multiclasses.

sklearn.multiclass Les modules sont devenus des problèmes de classification binaire pour résoudre des problèmes de classification multi-classes et multi-étiquettes. Décomposez ces problèmes pour obtenir une méta-estimation. La régression multi-cible est également prise en charge.

L'ensemble d'étiquettes peut varier d'une variable de sortie à une variable de sortie. Par exemple, vous pouvez attribuer "poire" à un échantillon pour les variables de sortie qui prennent des valeurs possibles dans un ensemble fini d'espèces telles que "poire" et "pomme". La deuxième variable de sortie "bleu" ou "vert" ... qui prend des valeurs possibles dans un ensemble fini de couleurs telles que "vert", "rouge", "bleu", "jaune" ...

Cela signifie que tout classificateur qui gère des tâches multi-classes à sorties multiples ou des tâches de classification multi-tâches prendra en charge les tâches de classification multi-étiquettes comme cas particulier. La classification multi-tâches est similaire à une tâche de classification multi-sortie avec différents formats de modèle. Consultez la documentation appropriée de l'estimateur pour plus d'informations.

Tous les classificateurs scikit-learn sont capables de classification multiclasse, mais le méta-estimateur fourni par sklearn.multiclass peut changer la façon dont il gère plus d'une classe. En effet, cela peut affecter les performances du classificateur (en termes d'erreur de généralisation ou de ressources de calcul requises). Voici un aperçu des classificateurs pris en charge par scikit-learn regroupés par stratégie. Sauf si vous avez besoin d'un comportement multi-classes personnalisé, vous n'avez pas besoin d'un outil de méta-estimation pour cette classe si vous utilisez l'un de ceux-ci.

Certains estimateurs prennent en charge les tâches de classification multi-sorties-multi-classes. Arbre de décision, forêt aléatoire, méthode du plus proche voisin.

** Attention: ** Actuellement, les métriques dans sklearn.metrics sont des tâches de classification multi-sorties-multi-classes Non supporté.

1.12.1. Format de classification multi-étiquettes

Dans l'apprentissage multi-étiquettes, l'ensemble conjoint des tâches de classification binaire est représenté par un tableau d'indicateurs binaires d'étiquettes. Chaque échantillon est une ligne de tableaux à deux dimensions (n_samples, n_classes) avec des valeurs binaires. Autrement dit, il s'agit d'un élément non nul. Un sous-ensemble d'étiquettes Un tableau tel que np.array ([[1,0,0], [0,1,1], [0,0,0]]) est étiqueté 0, second dans le premier échantillon. Les étiquettes des échantillons 1 et 2 et le troisième échantillon ne sont pas étiquetés. Il est plus intuitif de générer des données multi-étiquettes sous forme de liste d'ensembles d'étiquettes. MultiLabelBinarizer Vous pouvez utiliser le transformateur pour convertir la collection d'étiquettes et le format de l'indicateur.

>>> from sklearn.preprocessing import MultiLabelBinarizer
>>> y = [[2, 3, 4], [2], [0, 1, 3], [0, 1, 2, 3, 4], [0, 1, 2]]
>>> MultiLabelBinarizer().fit_transform(y)
array([[0, 0, 1, 1, 1],
       [0, 0, 1, 0, 0],
       [1, 1, 0, 1, 0],
       [1, 1, 1, 1, 1],
       [1, 1, 1, 0, 0]])

1.12.2. One-Vs-The-Rest

Cette stratégie est connue sous le nom de ** One-VS All ** et est connue sous le nom de OneVsRestClassifier Est implémenté. La stratégie consiste à adapter un classificateur par classe. Pour chaque classificateur, cette classe correspond à toutes les autres classes. En plus de son efficacité de calcul (seul le classificateur «n_classes» est requis), un avantage de cette approche est son interprétabilité. Puisque chaque classe est représentée par un seul et unique classificateur, il est possible d'acquérir des connaissances sur cette classe en examinant le classificateur correspondant. C'est la stratégie la plus couramment utilisée et c'est un choix par défaut juste.

1.12.2.1. Apprentissage multi-classes

Voici un exemple d'apprentissage multi-classes à l'aide d'OvR.

>>> from sklearn import datasets
>>> from sklearn.multiclass import OneVsRestClassifier
>>> from sklearn.svm import LinearSVC
>>> iris = datasets.load_iris()
>>> X, y = iris.data, iris.target
>>> OneVsRestClassifier(LinearSVC(random_state=0)).fit(X, y).predict(X)
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
       2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2,
       2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])

1.12.2.2. Apprentissage multi-étiquettes

OneVsRestClassifier prend également en charge la classification multi-étiquettes. Pour utiliser cette fonctionnalité, la cellule [i, j] envoie une matrice d'indicateur au classificateur indiquant la présence de l'étiquette j dans l'échantillon i.

--Exemple:

1.12.3. One-Vs-One

OneVsOneClassifier construit un classificateur pour chaque paire de classes. Au moment de la prédiction, la classe la plus votée sera sélectionnée. En cas d'égalité (entre deux classes avec le même nombre de votes), la classe avec la confiance de classification totale la plus élevée en ajoutant les niveaux de confiance de classification par paires calculés par le classificateur binaire sous-jacent. Sélectionner. Cette méthode est généralement plus lente que one-vs-the-rest en raison de sa complexité O (n_classes ^ 2), car les classificateurs pour n_classes * (n_classes -1) / 2 doivent être ajustés. Devenir. Cependant, cette méthode peut être avantageuse pour les algorithmes tels que les algorithmes du noyau qui ne correspondent pas bien à «n_samples». En effet, chaque problème d'apprentissage ne contient qu'un petit sous-ensemble de données, tandis que le reste de la paire utilise l'ensemble de données complet n_classes times.

1.12.3.1. Apprentissage multi-classes

Voici un exemple d'apprentissage multi-classes à l'aide d'OvO.

>>> from sklearn import datasets
>>> from sklearn.multiclass import OneVsOneClassifier
>>> from sklearn.svm import LinearSVC
>>> iris = datasets.load_iris()
>>> X, y = iris.data, iris.target
>>> OneVsOneClassifier(LinearSVC(random_state=0)).fit(X, y).predict(X)
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
       2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
       2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])

--Référence:

1.12.4. Code de sortie de correction d'erreur

Les stratégies basées sur le code de sortie sont assez différentes de one-vs-the-rest et one-vs-one. Dans ces stratégies, chaque classe est représentée dans l'espace euclidien et chaque dimension est seulement 0 ou 1. Alternativement, chaque classe est représentée par un code binaire (un tableau de 0 et 1). La matrice qui suit l'emplacement / le code de chaque classe est appelée un livre de codes. La taille du code est le nombre de dimensions de l'espace mentionné ci-dessus. Intuitivement, chaque classe doit être représentée dans un code aussi unique que possible, et un bon livre de codes doit être conçu pour optimiser la précision de la classification. Cette implémentation utilise simplement un livre de codes généré aléatoirement comme suggéré dans [3], mais peut ajouter des méthodes plus complexes à l'avenir. Au moment de l'ajustement, un classificateur binaire correspond à chaque bit du livre de codes. Au moment de la prédiction, le classificateur est utilisé pour projeter un nouveau point dans l'espace de classe et la classe la plus proche du point est sélectionnée. OutputCodeClassifier utilise l'attribut code_size pour utiliser le classificateur Vous pouvez contrôler le nombre de fichiers. Il s'agit d'un pourcentage du nombre total de classes.

Les nombres entre 0 et 1 nécessitent moins de classificateurs que le reste de la paire. En théorie, log2 (n_classes) / n_classes peut représenter explicitement chaque classe. Cependant, log2 (n_classes) est beaucoup plus petit que n_classes, ce qui peut en fait être moins précis. Les nombres supérieurs à 1 nécessitent plus de classificateurs que la paire restante de classificateurs. Dans ce cas, certains classificateurs corrigent théoriquement les erreurs faites par d'autres classificateurs, d'où le nom de «correction d'erreur». Cependant, en pratique, cela n'est pas possible car les erreurs de classificateur sont généralement corrélées. Le code de sortie de correction d'erreur a le même effet que l'ensachage.

1.12.4.1. Apprentissage multi-classes

Voici un exemple d'apprentissage multi-classes à l'aide du code de sortie.

>>> from sklearn import datasets
>>> from sklearn.multiclass import OutputCodeClassifier
>>> from sklearn.svm import LinearSVC
>>> iris = datasets.load_iris()
>>> X, y = iris.data, iris.target
>>> clf = OutputCodeClassifier(LinearSVC(random_state=0),
...                            code_size=2, random_state=0)
>>> clf.fit(X, y).predict(X)
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1,
       1, 2, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
       2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 1, 1, 2, 2, 2,
       2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])

--Référence:

1.12.5. Régression multi-sorties

Vous pouvez ajouter la prise en charge de la régression multi-sortie à tout analyseur de régression qui utilise MultiOutputRegressor. Cette stratégie consiste à appliquer un facteur de régression pour chaque objectif. Comme chaque cible est représentée par exactement une équation de régression, il est possible d'acquérir des connaissances sur la cible en examinant l'équation de régression correspondante. MultiOutputRegressor ajuste une équation de régression par cible, vous ne pouvez donc pas tirer parti de la corrélation entre les cibles. Voici un exemple de régression multi-sorties.

>>> from sklearn.datasets import make_regression
>>> from sklearn.multioutput import MultiOutputRegressor
>>> from sklearn.ensemble import GradientBoostingRegressor
>>> X, y = make_regression(n_samples=10, n_targets=3, random_state=1)
>>> MultiOutputRegressor(GradientBoostingRegressor(random_state=0)).fit(X, y).predict(X)
array([[-154.75474165, -147.03498585,  -50.03812219],
       [   7.12165031,    5.12914884,  -81.46081961],
       [-187.8948621 , -100.44373091,   13.88978285],
       [-141.62745778,   95.02891072, -191.48204257],
       [  97.03260883,  165.34867495,  139.52003279],
       [ 123.92529176,   21.25719016,   -7.84253   ],
       [-122.25193977,  -85.16443186, -107.12274212],
       [ -30.170388  ,  -94.80956739,   12.16979946],
       [ 140.72667194,  176.50941682,  -17.50447799],
       [ 149.37967282,  -81.15699552,   -5.72850319]])

1.12.6. Classification de plusieurs produits

La prise en charge de la classification de sortie multiple peut être ajoutée à tout classificateur qui utilise le MultiOutputClassifier. Cette stratégie consiste à adapter un classificateur pour chaque cible. Cela permet plusieurs classifications de variables cibles. Le but de cette classe est d'entraîner et d'estimer un ensemble de fonctions objectives (f1, f2, f3 ..., fn) avec une matrice prédictive X et de définir un ensemble de (y1, y2, y3 ..., yn) Est d'étendre l'estimateur afin qu'il puisse prédire la prédiction de.

Voici un exemple de classification à sorties multiples.

>>> from sklearn.datasets import make_classification
>>> from sklearn.multioutput import MultiOutputClassifier
>>> from sklearn.ensemble import RandomForestClassifier
>>> from sklearn.utils import shuffle
>>> import numpy as np
>>> X, y1 = make_classification(n_samples=10, n_features=100, n_informative=30, n_classes=3, random_state=1)
>>> y2 = shuffle(y1, random_state=1)
>>> y3 = shuffle(y1, random_state=2)
>>> Y = np.vstack((y1, y2, y3)).T
>>> n_samples, n_features = X.shape # 10,100
>>> n_outputs = Y.shape[1] # 3
>>> n_classes = 3
>>> forest = RandomForestClassifier(n_estimators=100, random_state=1)
>>> multi_target_forest = MultiOutputClassifier(forest, n_jobs=-1)
>>> multi_target_forest.fit(X, Y).predict(X)
array([[2, 2, 0],
       [1, 2, 1],
       [2, 1, 0],
       [0, 0, 2],
       [0, 2, 1],
       [0, 0, 2],
       [1, 1, 0],
       [1, 1, 1],
       [0, 0, 2],
       [2, 0, 0]])

[scikit-learn 0.18 Guide de l'utilisateur 1. Apprentissage supervisé](http://qiita.com/nazoking@github/items/267f2371757516f8c168#1-%E6%95%99%E5%B8%AB%E4%BB%98 À partir de% E3% 81% 8D% E5% AD% A6% E7% BF% 92)

© 2010 --2016, développeurs scikit-learn (licence BSD).

Recommended Posts

[Français] scikit-learn 0.18 Guide de l'utilisateur 1.12. Algorithme multi-classes et algorithme multi-étiquettes
[Français] scikit-learn 0.18 Guide de l'utilisateur 2.7. Détection des nouveautés et des valeurs aberrantes
[Français] scikit-learn 0.18 Guide de l'utilisateur 4.5. Projection aléatoire
[Français] scikit-learn 0.18 Guide de l'utilisateur 1.11. Méthode Ensemble
[Français] scikit-learn 0.18 Guide de l'utilisateur 4.2 Extraction de fonctionnalités
[Français] scikit-learn 0.18 Guide de l'utilisateur 1.16. Étalonnage des probabilités
[Français] scikit-learn 0.18 Guide de l'utilisateur 1.13 Sélection des fonctionnalités
[Français] scikit-learn 0.18 Guide de l'utilisateur 3.4. Persistance du modèle
[Français] scikit-learn 0.18 Guide de l'utilisateur 2.8. Estimation de la densité
[Français] scikit-learn 0.18 Guide de l'utilisateur 4.3. Prétraitement des données
[Français] scikit-learn 0.18 Guide de l'utilisateur 4.4. Réduction de dimension non supervisée
[Français] scikit-learn 0.18 Guide de l'utilisateur Table des matières
[Français] scikit-learn 0.18 Guide de l'utilisateur 1.4. Support Vector Machine
[Français] scikit-learn 0.18 Guide de l'utilisateur 4.1. Union des pipelines et des fonctionnalités: combinaison d'estimateurs
[Français] scikit-learn 0.18 Guide de l'utilisateur 3.2. Réglage des hyper paramètres de l'estimateur
[Français] scikit-learn 0.18 Guide de l'utilisateur 4.8. Convertir la cible de prédiction (y)
[Français] scikit-learn 0.18 Guide de l'utilisateur 3.1. Validation croisée: évaluer les performances de l'estimateur
[Français] scikit-learn 0.18 Guide de l'utilisateur 3.3. Évaluation du modèle: quantifier la qualité de la prédiction
Guide de l'utilisateur Pandas "fusionner et joindre et concaténer" (document officiel traduction japonaise)
[Français] scikit-learn 0.18 Guide de l'utilisateur 3.5. Courbe de vérification: tracez le score pour évaluer le modèle
[Français] scikit-learn 0.18 Guide de l'utilisateur 2.5. Décomposer les signaux en composants (problème de décomposition de la matrice)