Iris-Datensatz | Halbüberwachte Klassifizierer | Machine Learning

Einführung

In diesem Lab werden wir halbüberwachte Klassifizierer auf dem Iris-Datensatz untersuchen. Wir werden die Entscheidungsgrenzen, die von Label Spreading, Self-training und Support Vector Machine (SVM) auf dem Iris-Datensatz erzeugt werden, vergleichen. Wir werden die populäre Python-Maschinenlernbibliothek scikit-learn verwenden, um die Klassifizierer zu implementieren und die Entscheidungsgrenzen zu visualisieren.

VM-Tipps

Nachdem der VM-Start abgeschlossen ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu nutzen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund der Einschränkungen in Jupyter Notebook nicht automatisiert werden.

Wenn Sie während des Lernens Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.

Laden des Iris-Datensatzes und Aufteilung der Daten

Wir werden den Iris-Datensatz laden, der ein in der Maschinellen Lernung weit verbreiteter Datensatz für Klassifizierungsaufgaben ist. Der Datensatz enthält 150 Stichproben von Iris-Blüten, wobei jede Stichprobe vier Merkmale hat: Kelchblattlänge, Kelchblattbreite, Blütenblattlänge und Blütenblattbreite. Wir werden den Datensatz in Eingangsmerkmale und Zielbezeichnungen aufteilen.

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets

## Lade den Iris-Datensatz
iris = datasets.load_iris()

## Teile den Datensatz in Eingangsmerkmale und Zielbezeichnungen auf
X = iris.data[:, :2] ## Wir werden nur die ersten beiden Merkmale für die Visualisierung verwenden
y = iris.target

Einrichten der Label Spreading-Klassifizierer

Wir werden drei Label Spreading-Klassifizierer mit unterschiedlichen Prozentsätzen markierter Daten einrichten: 30%, 50% und 100%. Label Spreading ist ein halbüberwachtes Lernverfahren, das die Labels von markierten auf unmarkierte Datenpunkte basierend auf ihrer Ähnlichkeit weiterverbreitet.

from sklearn.semi_supervised import LabelSpreading

## Einrichten der Label Spreading-Klassifizierer
rng = np.random.RandomState(0)
y_rand = rng.rand(y.shape[0])
y_30 = np.copy(y)
y_30[y_rand < 0.3] = -1  ## setze zufällige Stichproben als unmarkiert
y_50 = np.copy(y)
y_50[y_rand < 0.5] = -1
ls30 = (LabelSpreading().fit(X, y_30), y_30, "Label Spreading 30% Daten")
ls50 = (LabelSpreading().fit(X, y_50), y_50, "Label Spreading 50% Daten")
ls100 = (LabelSpreading().fit(X, y), y, "Label Spreading 100% Daten")

Einrichten der Self-training-Klassifizierer

Wir werden zwei Self-training-Klassifizierer mit unterschiedlichen Prozentsätzen markierter Daten einrichten: 30% und 50%. Self-training ist ein halbüberwachtes Lernverfahren, das einen Klassifizierer auf den markierten Daten trainiert und dann verwendet, um die Labels der unmarkierten Daten vorherzusagen. Die am zuverlässigsten vorhergesagten Labels werden zu den markierten Daten hinzugefügt, und der Prozess wird wiederholt, bis die Konvergenz erreicht ist.

from sklearn.semi_supervised import SelfTrainingClassifier
from sklearn.svm import SVC

## Einrichten der Self-training-Klassifizierer
base_classifier = SVC(kernel="rbf", gamma=0.5, probability=True)
st30 = (
    SelfTrainingClassifier(base_classifier).fit(X, y_30),
    y_30,
    "Self-training 30% Daten",
)
st50 = (
    SelfTrainingClassifier(base_classifier).fit(X, y_50),
    y_50,
    "Self-training 50% Daten",
)

Einrichten des SVM-Klassifizierers

Wir werden einen SVM-Klassifizierer mit einem radial basis function (RBF)-Kernel einrichten. SVM ist ein überwachtes Lernverfahren, das die optimale Hyperebene sucht, die die Daten in verschiedene Klassen trennt.

from sklearn.svm import SVC

## Einrichten des SVM-Klassifizierers
rbf_svc = (SVC(kernel="rbf", gamma=0.5).fit(X, y), y, "SVC mit rbf-Kernel")

Visualisiere die Entscheidungsgrenzen

Wir werden ein Gitternetz von Punkten erstellen, das den Eingangsmerkmalraum abdeckt, und jede Klassifizierung verwenden, um die Labels für die Punkte im Gitternetz vorherzusagen. Anschließend werden wir die Entscheidungsgrenzen und die markierten Datenpunkte plotten.

## Erstelle ein Gitternetz zum Plotten
h = 0.02
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))

## Definiere eine Farbkarte für die Labels
color_map = {-1: (1, 1, 1), 0: (0, 0, 0.9), 1: (1, 0, 0), 2: (0.8, 0.6, 0)}

## Setze die Klassifizierer ein
classifiers = (ls30, st30, ls50, st50, ls100, rbf_svc)

## Plot die Entscheidungsgrenzen und die markierten Datenpunkte für jede Klassifizierung
for i, (clf, y_train, title) in enumerate(classifiers):
    ## Plot die Entscheidungsgrenze
    plt.subplot(3, 2, i + 1)
    Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])

    ## Bringe das Ergebnis in einen Farbplot
    Z = Z.reshape(xx.shape)
    plt.contourf(xx, yy, Z, cmap=plt.cm.Paired)
    plt.axis("off")

    ## Plot die markierten Datenpunkte
    colors = [color_map[y] for y in y_train]
    plt.scatter(X[:, 0], X[:, 1], c=colors, edgecolors="black")

    plt.title(title)

plt.suptitle("Unmarkierte Punkte sind weiß gefärbt", y=0.1)
plt.show()

Zusammenfassung

In diesem Lab haben wir halbüberwachte Klassifizierer auf dem Iris-Datensatz untersucht. Wir haben die Entscheidungsgrenzen, die von Label Spreading, Self-training und SVM auf dem Iris-Datensatz erzeugt werden, verglichen. Wir haben scikit-learn verwendet, um die Klassifizierer zu implementieren und die Entscheidungsgrenzen zu visualisieren. Wir haben festgestellt, dass Label Spreading und Self-training auch dann gute Entscheidungsgrenzen lernen können, wenn nur 少量 von markierten Daten verfügbar sind. （这里原文“少量”未翻译完整，可补充完整后再输出更准确的内容）

Halbüberwachte Klassifizierer auf dem Iris-Datensatz