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.

** Classification multi-classes ** signifie une tâche de classification avec deux classes ou plus. Par exemple, un ensemble d'images de fruits pouvant être orange, pomme ou poire peut être catégorisé. La multiclassification suppose que chaque échantillon est attribué à une seule et unique étiquette. Le fruit est soit une pomme soit une poire, mais pas les deux à la fois.
** La classification multi-étiquettes ** attribue un ensemble d'étiquettes cibles à chaque échantillon. Vous pouvez considérer cela comme une prédiction des propriétés des points de données qui ne sont pas mutuellement exclusifs, tels que les rubriques liées au document. Le texte peut être en même temps ou ni l'un ni l'autre de la religion, de la politique, des finances, de l'éducation.
** Régression multi-sortie ** attribue un ensemble de valeurs cibles à chaque échantillon. Cela peut être considéré comme une prédiction de certaines propriétés de chaque point de données, telles que la direction et la magnitude du vent à un endroit particulier.
** Multi-sortie - Classification multi-classes ** et ** Classification multi-tâches ** signifie qu'un seul estimateur doit gérer plusieurs tâches de co-classification. Il s'agit d'une généralisation des tâches de classification multi-étiquettes qui considère à la fois la classification binaire et la généralisation des tâches de classification multi-classes. Le format de sortie est un tableau à deux dimensions ou une matrice creuse.

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.

Essentiellement multiclasse: Naive Bayes, LDA et QDA, arbre de décision, forêt aléatoire, méthode du plus proche voisin, [sklearn.linear_model.LogisticRegression](http://scikit-learn.org/0.18/modules/generated/sklearn. Définissez multi_class = 'multinomial' dans linear_model.LogisticRegression.html # sklearn.linear_model.LogisticRegression).
Prise en charge multi-étiquettes: arbre de décision, forêt aléatoire, méthode du plus proche voisin.
One-Vs-One：sklearn.svm.SVC。 --One-Vs-All: tous les modèles linéaires sauf sklearn.svm.SVC.

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:

Classification multi-étiquettes

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] "Reconnaissance de formes et apprentissage automatique. Springer", Christopher M. Bishop, page 183, (1ère édition)

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:

[2] "Résolution des problèmes d'apprentissage multi-classes avec code de sortie de correction d'erreur", Dietterich T., Bakiri G., Journal of Artificial Intelligence Research 2, 1995.
[3] "Error Coding Method and PICT", James G., Hastie T., Journal of Computational and Graphical statistics 7, 1998
[4] "Elements of Statistical Learning", Hastie T., Tibshirani R., Friedman J., p. 606 (2e édition) 2008.

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)

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