google übersetzte http://scikit-learn.org/0.18/modules/multiclass.html [scikit-learn 0.18 Benutzerhandbuch 1. Überwachtes Lernen](http://qiita.com/nazoking@github/items/267f2371757516f8c168#1-%E6%95%99%E5%B8%AB%E4%BB%98 Von% E3% 81% 8D% E5% AD% A6% E7% BF% 92)

1.12 Multi-Klassen-Algorithmus und Multi-Label-Algorithmus

** WARNUNG **: Alle Scikit-Learn-Klassifizierer bieten eine gebrauchsfertige Klassifizierung für mehrere Klassen. Sie müssen das Modul sklearn.multiclass nur verwenden, wenn Sie verschiedene Strategien für mehrere Klassen ausprobiert haben.

sklearn.multiclass Module sind zu binären Klassifizierungsproblemen geworden, um Klassifizierungsprobleme mit mehreren Klassen und mehreren Labels zu lösen Zerlegen Sie diese Probleme, um eine Metaschätzung zu erhalten. Die Multi-Target-Regression wird ebenfalls unterstützt.

** Mehrklassenklassifizierung ** bezeichnet eine Klassifizierungsaufgabe mit zwei oder mehr Klassen. Beispielsweise kann eine Reihe von Bildern von Früchten, die Orange, Apfel oder Birne sein können, kategorisiert werden. Bei der Mehrfachklassifizierung wird davon ausgegangen, dass jede Probe einem einzigen Etikett zugeordnet ist. Die Frucht ist entweder ein Apfel oder eine Birne, aber nicht beide gleichzeitig.
** Klassifizierung mit mehreren Etiketten ** weist jeder Probe einen Satz von Zieletiketten zu. Sie können sich dies als Vorhersage der Eigenschaften von Datenpunkten vorstellen, die sich nicht gegenseitig ausschließen, z. B. Themen, die sich auf das Dokument beziehen. Der Text kann gleichzeitig mit Religion, Politik, Finanzen und Bildung sein oder auch nicht.
** Multi-Output-Regression ** weist jeder Stichprobe eine Reihe von Zielwerten zu. Dies kann als Vorhersage einiger Eigenschaften jedes Datenpunkts angesehen werden, wie z. B. der Richtung und Stärke des Windes an einem bestimmten Ort.
** Multi-Output - Multi-Class-Klassifizierung ** und ** Multi-Task-Klassifizierung ** bedeutet, dass ein einzelner Schätzer mehrere Co-Classification-Aufgaben ausführen muss. Dies ist eine Verallgemeinerung von Klassifizierungsaufgaben mit mehreren Etiketten, die sowohl die binäre Klassifizierung als auch die Verallgemeinerung von Klassifizierungsaufgaben mit mehreren Klassen berücksichtigt. Das Ausgabeformat ist ein zweidimensionales Array oder eine dünn besetzte Matrix.

Der Satz von Beschriftungen kann von Ausgabevariable zu Ausgabevariable variieren. Beispielsweise können Sie einer Stichprobe "Birne" für Ausgabevariablen zuweisen, die mögliche Werte in einer endlichen Menge von Arten wie "Birne" und "Apfel" annehmen. Die zweite Ausgabevariable "blau" oder "grün" ... die mögliche Werte in einer endlichen Menge von Farben wie "grün", "rot", "blau", "gelb" annimmt ...

Dies bedeutet, dass jeder Klassifizierer, der Multi-Output-Multi-Class-Aufgaben oder Multi-Task-Klassifizierungsaufgaben verarbeitet, als Sonderfall Multi-Label-Klassifizierungsaufgaben unterstützt. Die Multitask-Klassifizierung ähnelt einer Multi-Output-Klassifizierungsaufgabe mit verschiedenen Modellformaten. Weitere Informationen finden Sie in der entsprechenden Dokumentation zum Schätzer.

Alle Scikit-Learn-Klassifizierer können mehrere Klassen klassifizieren, aber der von sklearn.multiclass bereitgestellte Meta-Schätzer kann die Art und Weise ändern, wie mehr als eine Klasse behandelt wird. Dies liegt daran, dass dies die Leistung des Klassifizierers beeinträchtigen kann (in Bezug auf Generalisierungsfehler oder erforderliche Rechenressourcen). Das Folgende ist eine Übersicht über die Klassifikatoren, die von scikit-learn unterstützt werden, gruppiert nach Strategie. Sofern Sie kein benutzerdefiniertes Verhalten für mehrere Klassen benötigen, benötigen Sie für diese Klasse kein Meta-Schätzwerkzeug, wenn Sie eines dieser Tools verwenden.

Im Wesentlichen Multiklasse: Naive Bayes, LDA und QDA, Entscheidungsbaum, Zufallswald, Methode des nächsten Nachbarn, [sklearn.linear_model.LogisticRegression](http://scikit-learn.org/0.18/modules/generated/sklearn. Setzen Sie multi_class = 'multinomial' in linear_model.LogisticRegression.html # sklearn.linear_model.LogisticRegression).
Multi-Label-Unterstützung: Entscheidungsbaum, zufällige Gesamtstruktur, Methode des nächsten Nachbarn.
One-Vs-One：sklearn.svm.SVC。 --One-Vs-All: Alle linearen Modelle außer sklearn.svm.SVC.

Einige Schätzer unterstützen Klassifizierungsaufgaben mit mehreren Ausgaben und mehreren Klassen. Entscheidungsbaum, zufällige Gesamtstruktur, Methode des nächsten Nachbarn.

** Warnung: ** Derzeit sind die Metriken in sklearn.metrics Klassifizierungsaufgaben mit mehreren Ausgaben und mehreren Klassen Nicht unterstützt.

1.12.1. Klassifizierungsformat für mehrere Etiketten

Beim Multi-Label-Lernen wird der gemeinsame Satz von binären Klassifizierungsaufgaben durch ein Label-Binärindikator-Array dargestellt. Jedes Sample ist eine Reihe zweidimensionaler Arrays (n_samples, n_classes) mit Binärwerten. Das heißt, es ist ein Nicht-Null-Element. Eine Teilmenge von Beschriftungen Ein Array wie "np.array ([[1,0,0], [0,1,1], [0,0,0]])" wird im ersten Beispiel mit 0 als Sekunde bezeichnet. Die Probenetiketten 1 und 2 sowie die dritte Probe sind unbeschriftet. Es ist intuitiver, Daten mit mehreren Etiketten als Liste von Etikettensätzen zu generieren. MultiLabelBinarizer Mit dem Transformator können Sie die Sammlung von Etiketten und das Indikatorformat konvertieren.

>>> 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

Diese Strategie ist als ** One-VS All ** und als [OneVsRestClassifier] bekannt (http://scikit-learn.org/0.18/modules/generated/sklearn.multiclass.OneVsRestClassifier.html#sklearn.multiclass.OneVsRestClassifier). ) Ist implementiert. Die Strategie besteht darin, einen Klassifikator pro Klasse anzupassen. Für jeden Klassifikator passt diese Klasse zu allen anderen Klassen. Ein Vorteil dieses Ansatzes ist neben seiner Recheneffizienz (nur der Klassifikator "n_classes" ist erforderlich) die Interpretierbarkeit. Da jede Klasse durch einen einzigen Klassifikator dargestellt wird, ist es möglich, durch Untersuchen des entsprechenden Klassifikators Kenntnisse über diese Klasse zu erlangen. Dies ist die am häufigsten verwendete Strategie und eine faire Standardwahl.

1.12.2.1 Lernen in mehreren Klassen

Das Folgende ist ein Beispiel für das Lernen in mehreren Klassen mit 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 Multi-Label-Lernen

OneVsRestClassifier unterstützt auch die Klassifizierung mehrerer Labels. Um diese Funktion zu verwenden, sendet Zelle [i, j] eine Indikatormatrix an den Klassifizierer, die das Vorhandensein des Etiketts j in Probe i anzeigt.

--Beispiel:

Multilabel-Klassifizierung

1.12.3. One-Vs-One

OneVsOneClassifier erstellt einen Klassifizierer für jedes Klassenpaar. Zum Zeitpunkt der Vorhersage wird die am meisten gewählte Klasse ausgewählt. Wenn es ein Unentschieden gibt (zwischen zwei Klassen mit der gleichen Anzahl von Stimmen), die Klasse mit dem höchsten Gesamtklassifizierungsvertrauen, indem die vom zugrunde liegenden binären Klassifizierer berechneten gepaarten Klassifizierungsvertrauensniveaus addiert werden. Wählen. Diese Methode ist aufgrund ihrer O (n_classes ^ 2) -Komplexität normalerweise langsamer als one-vs-the-rest, da die Klassifizierer für n_classes * (n_classes -1) / 2 angepasst werden müssen. Werden. Diese Methode kann jedoch für Algorithmen wie Kernel-Algorithmen vorteilhaft sein, die nicht gut zu "n_samples" passen. Dies liegt daran, dass jedes Lernproblem nur eine kleine Teilmenge der Daten enthält, während der Rest des Paares den vollständigen Datensatz n_classes mal verwendet.

1.12.3.1 Lernen in mehreren Klassen

Das Folgende ist ein Beispiel für das Lernen in mehreren Klassen mit 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])

--Referenz:

[1] "Mustererkennung und maschinelles Lernen. Springer", Christopher M. Bishop, Seite 183, (1. Auflage)

1.12.4 Fehlerkorrektur-Ausgabecode

Ausgabecode-basierte Strategien unterscheiden sich erheblich von One-vs-the-Rest und One-vs-One. In diesen Strategien wird jede Klasse im euklidischen Raum dargestellt und jede Dimension ist nur 0 oder 1. Alternativ wird jede Klasse durch einen Binärcode (ein Array von 0s und 1s) dargestellt. Die Matrix, die den Ort / Code jeder Klasse verfolgt, wird als Codebuch bezeichnet. Die Codegröße ist die Anzahl der Dimensionen des oben genannten Raums. Intuitiv sollte jede Klasse in einem möglichst eindeutigen Code dargestellt werden, und ein gutes Codebuch sollte entworfen werden, um die Klassifizierungsgenauigkeit zu optimieren. Diese Implementierung verwendet einfach ein zufällig generiertes Codebuch, wie in [3] vorgeschlagen, kann jedoch in Zukunft komplexere Methoden hinzufügen. Zum Zeitpunkt der Anpassung passt ein binärer Klassifizierer für jedes Bit im Codebuch. Zum Zeitpunkt der Vorhersage wird der Klassifizierer verwendet, um einen neuen Punkt in den Klassenraum zu projizieren, und die Klasse, die dem Punkt am nächsten liegt, wird ausgewählt. OutputCodeClassifier verwendet das Attribut code_size, um den Klassifizierer zu verwenden Sie können die Anzahl der steuern. Dies ist ein Prozentsatz der Gesamtzahl der Klassen.

Zahlen zwischen 0 und 1 erfordern weniger Klassifizierer als der Rest des Paares. Theoretisch kann "log2 (n_classes) / n_classes" jede Klasse explizit darstellen. "Log2 (n_classes)" ist jedoch viel kleiner als "n_classes", was tatsächlich weniger genau sein kann. Zahlen größer als 1 erfordern mehr Klassifizierer als das verbleibende Klassifiziererpaar. In diesem Fall korrigieren einige Klassifizierer theoretisch Fehler, die von anderen Klassifizierern gemacht wurden, daher der Name "Fehlerkorrektur". In der Praxis ist dies jedoch nicht möglich, da Klassifikatorfehler im Allgemeinen korrelieren. Der Fehlerkorrektur-Ausgabecode hat den gleichen Effekt wie das Absacken.

1.12.4.1 Lernen in mehreren Klassen

Das Folgende ist ein Beispiel für das Lernen in mehreren Klassen unter Verwendung von Ausgabecode.

>>> 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])

--Referenz:

[2] "Lösen von Lernproblemen in mehreren Klassen mit Fehlerkorrektur-Ausgabecode", Dietterich T., Bakiri G., Journal of Artificial Intelligence Research 2, 1995.
[3] "Fehlercodierungsmethode und PICT", James G., Hastie T., Journal of Computational and Graphical Statistics 7, 1998
[4] "Elemente des statistischen Lernens", Hastie T., Tibshirani R., Friedman J., S. 606 (2. Auflage) 2008.

1.12.5. Multi-Output-Regression

Sie können jedem Regressionsanalysator, der MultiOutputRegressor verwendet, Regressionsunterstützung mit mehreren Ausgaben hinzufügen. Diese Strategie besteht darin, für jedes Ziel einen Regressionsfaktor anzuwenden. Da jedes Ziel durch genau eine Regressionsgleichung dargestellt wird, ist es möglich, durch Untersuchen der entsprechenden Regressionsgleichung Kenntnisse über das Ziel zu erlangen. MultiOutputRegressor passt eine Regressionsgleichung pro Ziel an, sodass Sie die Korrelation zwischen Zielen nicht nutzen können. Das Folgende ist ein Beispiel für eine Regression mit mehreren Ausgaben.

>>> 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. Klassifizierung mehrerer Ausgänge

Die Unterstützung mehrerer Ausgabeklassifizierungen kann jedem Klassifizierer hinzugefügt werden, der den MultiOutputClassifier verwendet. Diese Strategie besteht darin, einen Klassifikator für jedes Ziel anzupassen. Dies ermöglicht mehrere Klassifizierungen von Zielvariablen. Der Zweck dieser Klasse besteht darin, eine Menge von Zielfunktionen (f1, f2, f3 ..., fn) mit einer X-Prädiktormatrix zu trainieren und zu schätzen und eine Menge von (y1, y2, y3 ..., yn) zu setzen. Ist es, den Schätzer so zu erweitern, dass er die Vorhersage von vorhersagen kann.

Das Folgende ist ein Beispiel für eine Klassifizierung mit mehreren Ausgaben.

>>> 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 Benutzerhandbuch 1. Überwachtes Lernen](http://qiita.com/nazoking@github/items/267f2371757516f8c168#1-%E6%95%99%E5%B8%AB%E4%BB%98 Von% E3% 81% 8D% E5% AD% A6% E7% BF% 92)

[PYTHON] [Übersetzung] scikit-learn 0.18 Benutzerhandbuch 1.12. Mehrklassenalgorithmus und Mehrfachetikettenalgorithmus