Mehrfaches Dokumentenklassifizierung

Einführung

In diesem Lab wird ein mehrfaches Dokumentklassifizierungsproblem mit scikit-learn demonstriert. Der Datensatz wird zufällig basierend auf dem folgenden Prozess generiert:

• Wähle die Anzahl der Labels: n ~ Poisson(n_labels)
• N-mal wähle eine Klasse c: c ~ Multinomial(theta)
• Wähle die Dokumentlänge: k ~ Poisson(length)
• K-mal wähle ein Wort: w ~ Multinomial(theta_c)

Bei diesem Prozess wird das Verwerfungs-Sampling verwendet, um sicherzustellen, dass n größer als 2 ist und dass die Dokumentlänge niemals Null ist. Ebenso werden bereits gewählte Klassen verworfen. Die Dokumente, die beiden Klassen zugewiesen sind, werden als Punkte umgeben von zwei gefärbten Kreisen geplottet.

Tipps für die VM

Nachdem der VM-Start abgeschlossen ist, klicke in der linken oberen 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 von Einschränkungen in Jupyter Notebook nicht automatisiert werden.

Wenn Sie bei der Lernphase Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.

Bibliotheken importieren

In diesem Schritt importieren wir die erforderlichen Bibliotheken: numpy, matplotlib, make_multilabel_classification aus sklearn.datasets, OneVsRestClassifier und SVC aus sklearn.multiclass, PCA und CCA aus sklearn.decomposition.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_multilabel_classification
from sklearn.multiclass import OneVsRestClassifier
from sklearn.svm import SVC
from sklearn.decomposition import PCA
from sklearn.cross_decomposition import CCA

Plotfunktion definieren

In diesem Schritt definieren wir die Funktionen plot_hyperplane und plot_subfigure. Die plot_hyperplane-Funktion wird verwendet, um die trennende Hyperebene zu erhalten, während die plot_subfigure-Funktion verwendet wird, um die Teilplots zu zeichnen.

def plot_hyperplane(clf, min_x, max_x, linestyle, label):
    ## get the separating hyperplane
    w = clf.coef_[0]
    a = -w[0] / w[1]
    xx = np.linspace(min_x - 5, max_x + 5)  ## make sure the line is long enough
    yy = a * xx - (clf.intercept_[0]) / w[1]
    plt.plot(xx, yy, linestyle, label=label)


def plot_subfigure(X, Y, subplot, title, transform):
    if transform == "pca":
        X = PCA(n_components=2).fit_transform(X)
    elif transform == "cca":
        X = CCA(n_components=2).fit(X, Y).transform(X)
    else:
        raise ValueError

    min_x = np.min(X[:, 0])
    max_x = np.max(X[:, 0])

    min_y = np.min(X[:, 1])
    max_y = np.max(X[:, 1])

    classif = OneVsRestClassifier(SVC(kernel="linear"))
    classif.fit(X, Y)

    plt.subplot(2, 2, subplot)
    plt.title(title)

    zero_class = np.where(Y[:, 0])
    one_class = np.where(Y[:, 1])
    plt.scatter(X[:, 0], X[:, 1], s=40, c="gray", edgecolors=(0, 0, 0))
    plt.scatter(
        X[zero_class, 0],
        X[zero_class, 1],
        s=160,
        edgecolors="b",
        facecolors="none",
        linewidths=2,
        label="Klasse 1",
    )
    plt.scatter(
        X[one_class, 0],
        X[one_class, 1],
        s=80,
        edgecolors="orange",
        facecolors="none",
        linewidths=2,
        label="Klasse 2",
    )

    plot_hyperplane(
        classif.estimators_[0], min_x, max_x, "k--", "Grenze\nfür Klasse 1"
    )
    plot_hyperplane(
        classif.estimators_[1], min_x, max_x, "k-.", "Grenze\nfür Klasse 2"
    )
    plt.xticks(())
    plt.yticks(())

    plt.xlim(min_x - 0.5 * max_x, max_x + 0.5 * max_x)
    plt.ylim(min_y - 0.5 * max_y, max_y + 0.5 * max_y)
    if subplot == 2:
        plt.xlabel("Erster Hauptkomponente")
        plt.ylabel("Zweite Hauptkomponente")
        plt.legend(loc="upper left")

Datensatz generieren

In diesem Schritt generieren wir den Datensatz mit der Funktion make_multilabel_classification aus sklearn.datasets.

X, Y = make_multilabel_classification(
    n_classes=2, n_labels=1, allow_unlabeled=True, random_state=1
)

Teilplots zeichnen

In diesem Schritt verwenden wir die Funktion plot_subfigure, um die Teilplots zu zeichnen.

plt.figure(figsize=(8, 6))

plot_subfigure(X, Y, 1, "Mit unmarkierten Proben + CCA", "cca")
plot_subfigure(X, Y, 2, "Mit unmarkierten Proben + PCA", "pca")

X, Y = make_multilabel_classification(
    n_classes=2, n_labels=1, allow_unlabeled=False, random_state=1
)

plot_subfigure(X, Y, 3, "Ohne unmarkierte Proben + CCA", "cca")
plot_subfigure(X, Y, 4, "Ohne unmarkierte Proben + PCA", "pca")

plt.subplots_adjust(0.04, 0.02, 0.97, 0.94, 0.09, 0.2)
plt.show()

Zusammenfassung

In diesem Lab wurde ein mehrfaches Dokumentenklassifizierungsproblem mit scikit-learn demonstriert. Wir haben die Funktion make_multilabel_classification verwendet, um den Datensatz zu generieren, und die Funktion plot_subfigure, um die Teilplots zu zeichnen.