Classification de texte semi-supervisée

Introduction

Dans ce laboratoire, vous allez apprendre à effectuer une classification semi-supervisée sur un ensemble de données textuelles à l'aide de scikit-learn. L'apprentissage semi-supervisé est un type d'apprentissage automatique où un modèle est entraîné sur des données étiquetées et non étiquetées. Ce laboratoire couvrira la manière d'utiliser les algorithmes Self-Training et LabelSpreading pour la classification textuelle semi-supervisée. Nous utiliserons l'ensemble de données 20 newsgroups pour entraîner et tester nos modèles.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook pour accéder à Jupyter Notebook pour la pratique.

Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez votre feedback après la session, et nous résoudrons rapidement le problème pour vous.

Charger l'ensemble de données

Nous utiliserons l'ensemble de données 20 newsgroups, qui contient environ 18 000 messages de newsgroup sur 20 sujets. Dans cette étape, nous allons charger l'ensemble de données et afficher quelques informations de base à son sujet.

import numpy as np
from sklearn.datasets import fetch_20newsgroups

## Charger l'ensemble de données avec les cinq premières catégories
data = fetch_20newsgroups(
    subset="train",
    categories=[
        "alt.atheism",
        "comp.graphics",
        "comp.os.ms-windows.misc",
        "comp.sys.ibm.pc.hardware",
        "comp.sys.mac.hardware",
    ],
)

## Afficher des informations sur l'ensemble de données
print("%d documents" % len(data.filenames))
print("%d catégories" % len(data.target_names))

Créer le pipeline pour l'apprentissage supervisé

Dans cette étape, nous allons créer un pipeline pour l'apprentissage supervisé. Le pipeline comprendra un CountVectorizer pour convertir les données textuelles en une matrice de comptes de jetons, un TfidfTransformer pour appliquer la normalisation fréquence de terme - fréquence inverse de document à la matrice de comptes, et un SGDClassifier pour entraîner le modèle.

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

## Paramètres pour le SGDClassifier
sdg_params = dict(alpha=1e-5, penalty="l2", loss="log_loss")

## Paramètres pour le CountVectorizer
vectorizer_params = dict(ngram_range=(1, 2), min_df=5, max_df=0.8)

## Créer le pipeline
pipeline = Pipeline(
    [
        ("vect", CountVectorizer(**vectorizer_params)),
        ("tfidf", TfidfTransformer()),
        ("clf", SGDClassifier(**sdg_params)),
    ]
)

Entraîner et évaluer le modèle supervisé

Dans cette étape, nous allons diviser l'ensemble de données en ensembles d'entraînement et de test, puis entraîner et évaluer le pipeline de modèle supervisé que nous avons créé dans l'Étape 2.

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

## Diviser l'ensemble de données en ensembles d'entraînement et de test
X, y = data.data, data.target
X_train, X_test, y_train, y_test = train_test_split(X, y)

## Entraîner et évaluer le pipeline de modèle supervisé
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")
)

Créer le pipeline pour l'auto-apprentissage

Dans cette étape, nous allons créer un pipeline pour l'apprentissage semi-supervisé utilisant l'auto-apprentissage. Le pipeline sera similaire au pipeline supervisé, mais nous utiliserons le SelfTrainingClassifier au lieu du SGDClassifier.

from sklearn.semi_supervised import SelfTrainingClassifier

## Créer le pipeline d'auto-apprentissage
st_pipeline = Pipeline(
    [
        ("vect", CountVectorizer(**vectorizer_params)),
        ("tfidf", TfidfTransformer()),
        ("clf", SelfTrainingClassifier(SGDClassifier(**sdg_params), verbose=True)),
    ]
)

Entraîner et évaluer le modèle d'auto-apprentissage

Dans cette étape, nous allons utiliser l'auto-apprentissage sur 20 % des données étiquetées. Nous allons sélectionner au hasard 20 % des données étiquetées, entraîner le modèle sur ces données, puis utiliser le modèle pour prédire les étiquettes pour les données non étiquetées restantes.

import numpy as np

## Sélectionner 20 % des données d'entraînement
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))
)

## Définir le sous-ensemble non masqué comme étant non étiqueté
y_train[~y_mask] = -1

## Entraîner et évaluer le pipeline d'auto-apprentissage
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")
)

Créer le pipeline pour la diffusion d'étiquettes

Dans cette étape, nous allons créer un pipeline pour l'apprentissage semi-supervisé utilisant la diffusion d'étiquettes. Le pipeline sera similaire au pipeline supervisé, mais nous utiliserons l'algorithme de diffusion d'étiquettes au lieu du SGDClassifier.

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

## Créer le pipeline de diffusion d'étiquettes
ls_pipeline = Pipeline(
    [
        ("vect", CountVectorizer(**vectorizer_params)),
        ("tfidf", TfidfTransformer()),
        ("toarray", FunctionTransformer(lambda x: x.toarray())),
        ("clf", LabelSpreading()),
    ]
)

Entraîner et évaluer le modèle de diffusion d'étiquettes

Dans cette étape, nous allons utiliser la diffusion d'étiquettes sur 20 % des données étiquetées. Nous allons sélectionner au hasard 20 % des données étiquetées, entraîner le modèle sur ces données, puis utiliser le modèle pour prédire les étiquettes pour les données non étiquetées restantes.

## Entraîner et évaluer le pipeline de diffusion d'étiquettes
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")
)

Sommaire

Dans ce laboratoire, nous avons appris à effectuer une classification semi-supervisée sur un ensemble de données textuelles à l'aide de scikit-learn. Nous avons utilisé les algorithmes d'auto-apprentissage et de diffusion d'étiquettes pour entraîner et tester nos modèles. L'apprentissage semi-supervisé peut être utile lorsqu'il y a un nombre limité de données étiquetées disponibles, et il peut aider à améliorer les performances d'un modèle en incorporant des données non étiquetées.