Halbüberwachte Textklassifizierung

Einführung

In diesem Lab erfahren Sie, wie Sie eine halbüberwachte Klassifizierung auf einem Textdatensatz mit scikit-learn durchführen können. Halbüberwachtes Lernen ist eine Art maschinelles Lernen, bei dem ein Modell sowohl auf gelabelten als auch auf ungelabelten Daten trainiert wird. In diesem Lab wird erläutert, wie Sie die Algorithmen Self-Training und LabelSpreading für die halbüberwachte Textklassifizierung verwenden können. Wir werden den 20 newsgroups-Datensatz verwenden, um unsere Modelle zu trainieren und zu testen.

Tipps für die virtuelle Maschine (VM)

Nachdem die VM gestartet wurde, klicken Sie in der oberen linken Ecke auf die Registerkarte Notebook, um auf Jupyter Notebook für die Übung zuzugreifen.

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

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

Laden des Datensatzes

Wir werden den 20 newsgroups-Datensatz verwenden, der etwa 18.000 Newsgroup-Beiträge zu 20 Themen enthält. In diesem Schritt laden wir den Datensatz und geben einige grundlegende Informationen darüber aus.

import numpy as np
from sklearn.datasets import fetch_20newsgroups

## Laden des Datensatzes mit den ersten fünf Kategorien
data = fetch_20newsgroups(
    subset="train",
    categories=[
        "alt.atheism",
        "comp.graphics",
        "comp.os.ms-windows.misc",
        "comp.sys.ibm.pc.hardware",
        "comp.sys.mac.hardware",
    ],
)

## Ausgabe von Informationen über den Datensatz
print("%d documents" % len(data.filenames))
print("%d categories" % len(data.target_names))

Erstellen der Pipeline für überwachtes Lernen

In diesem Schritt erstellen wir eine Pipeline für überwachtes Lernen. Die Pipeline besteht aus einem CountVectorizer, um die Textdaten in eine Matrix von Token-Zählungen umzuwandeln, einem TfidfTransformer, um die Termfrequenz-Inverse-Dokumentfrequenz-Normalisierung auf die Zählmatrix anzuwenden, und einem SGDClassifier, um das Modell zu trainieren.

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfTransformer
from sklearn.linear_model import SGDClassifier
from sklearn.pipeline import Pipeline

## Parameter für den SGDClassifier
sdg_params = dict(alpha=1e-5, penalty="l2", loss="log_loss")

## Parameter für den CountVectorizer
vectorizer_params = dict(ngram_range=(1, 2), min_df=5, max_df=0.8)

## Erstellen der Pipeline
pipeline = Pipeline(
    [
        ("vect", CountVectorizer(**vectorizer_params)),
        ("tfidf", TfidfTransformer()),
        ("clf", SGDClassifier(**sdg_params)),
    ]
)

Trainieren und Evaluieren des überwachten Modells

In diesem Schritt teilen wir den Datensatz in Trainings- und Testsets auf und trainieren und evaluieren dann die Pipeline für das überwachte Modell, die wir in Schritt 2 erstellt haben.

from sklearn.model_selection import train_test_split
from sklearn.metrics import f1_score

## Teilen des Datensatzes in Trainings- und Testsets
X, y = data.data, data.target
X_train, X_test, y_train, y_test = train_test_split(X, y)

## Trainieren und Evaluieren der Pipeline für das überwachte Modell
pipeline.fit(X_train, y_train)
y_pred = pipeline.predict(X_test)
print(
    "Micro-averaged F1 score on test set: %0.3f"
    % f1_score(y_test, y_pred, average="micro")
)

Erstellen der Pipeline für Self-Training

In diesem Schritt erstellen wir eine Pipeline für halbüberwachtes Lernen unter Verwendung von Self-Training. Die Pipeline wird der überwachten Pipeline ähneln, aber wir werden den SelfTrainingClassifier anstelle des SGDClassifier verwenden.

from sklearn.semi_supervised import SelfTrainingClassifier

## Erstellen der Self-Training-Pipeline
st_pipeline = Pipeline(
    [
        ("vect", CountVectorizer(**vectorizer_params)),
        ("tfidf", TfidfTransformer()),
        ("clf", SelfTrainingClassifier(SGDClassifier(**sdg_params), verbose=True)),
    ]
)

Trainieren und Evaluieren des Self-Training-Modells

In diesem Schritt verwenden wir Self-Training auf 20 % der gelabelten Daten. Wir wählen zufällig 20 % der gelabelten Daten aus, trainieren das Modell auf diesen Daten und verwenden dann das Modell, um Labels für die verbleibenden ungelabelten Daten vorherzusagen.

import numpy as np

## Auswahl von 20 % der Trainingsdaten
y_mask = np.random.rand(len(y_train)) < 0.2
X_20, y_20 = map(
    list, zip(*((x, y) for x, y, m in zip(X_train, y_train, y_mask) if m))
)

## Setzen der nicht markierten Teilmenge auf ungelabelt
y_train[~y_mask] = -1

## Trainieren und Evaluieren der Self-Training-Pipeline
st_pipeline.fit(X_train, y_train)
y_pred = st_pipeline.predict(X_test)
print(
    "Micro-averaged F1 score on test set: %0.3f"
    % f1_score(y_test, y_pred, average="micro")
)

Erstellen der Pipeline für LabelSpreading

In diesem Schritt erstellen wir eine Pipeline für halbüberwachtes Lernen unter Verwendung von LabelSpreading. Die Pipeline wird der überwachten Pipeline ähneln, aber wir werden den LabelSpreading-Algorithmus anstelle des SGDClassifier verwenden.

from sklearn.semi_supervised import LabelSpreading
from sklearn.preprocessing import FunctionTransformer

## Erstellen der LabelSpreading-Pipeline
ls_pipeline = Pipeline(
    [
        ("vect", CountVectorizer(**vectorizer_params)),
        ("tfidf", TfidfTransformer()),
        ("toarray", FunctionTransformer(lambda x: x.toarray())),
        ("clf", LabelSpreading()),
    ]
)

Trainieren und Evaluieren des LabelSpreading-Modells

In diesem Schritt verwenden wir LabelSpreading auf 20 % der gelabelten Daten. Wir wählen zufällig 20 % der gelabelten Daten aus, trainieren das Modell auf diesen Daten und verwenden dann das Modell, um Labels für die verbleibenden ungelabelten Daten vorherzusagen.

## Train and evaluate the LabelSpreading pipeline
ls_pipeline.fit(X_train, y_train)
y_pred = ls_pipeline.predict(X_test)
print(
    "Micro-averaged F1 score on test set: %0.3f"
    % f1_score(y_test, y_pred, average="micro")
)

Zusammenfassung

In diesem Lab haben wir gelernt, wie man halbüberwachte Klassifizierung auf einem Textdatensatz mit scikit-learn durchführt. Wir haben die Self-Training- und LabelSpreading-Algorithmen verwendet, um unsere Modelle zu trainieren und zu testen. Halbüberwachtes Lernen kann nützlich sein, wenn nur eine begrenzte Menge an gelabelten Daten verfügbar ist, und es kann dazu beitragen, die Leistung eines Modells zu verbessern, indem ungelabelte Daten einbezogen werden.