Classification de documents multi-étiquette

Introduction

Ce laboratoire démontre un problème de classification de documents multi-étiquettes à l'aide de scikit-learn. Le jeu de données est généré aléatoirement selon le processus suivant :

Choisissez le nombre d'étiquettes : n ~ Poisson(n_labels)
N fois, choisissez une classe c : c ~ Multinomial(theta)
Choisissez la longueur du document : k ~ Poisson(length)
K fois, choisissez un mot : w ~ Multinomial(theta_c)

Dans ce processus, l'échantillonnage par rejet est utilisé pour s'assurer que n est supérieur à 2 et que la longueur du document n'est jamais nulle. De même, les classes déjà choisies sont rejetées. Les documents assignés à les deux classes sont tracés entourés de deux cercles colorés.

Conseils sur la VM

Une fois le démarrage de la VM 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 limites 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.

Importation des bibliothèques

Dans cette étape, nous importons les bibliothèques nécessaires : numpy, matplotlib, make_multilabel_classification de sklearn.datasets, OneVsRestClassifier et SVC de sklearn.multiclass, PCA et CCA de 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

Définition de la fonction de tracé

Dans cette étape, nous définissons les fonctions plot_hyperplane et plot_subfigure. La fonction plot_hyperplane est utilisée pour obtenir l'hyperplan de séparation tandis que la fonction plot_subfigure est utilisée pour tracer les sous-graphiques.

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="Class 1",
    )
    plt.scatter(
        X[one_class, 0],
        X[one_class, 1],
        s=80,
        edgecolors="orange",
        facecolors="none",
        linewidths=2,
        label="Class 2",
    )

    plot_hyperplane(
        classif.estimators_[0], min_x, max_x, "k--", "Boundary\nfor class 1"
    )
    plot_hyperplane(
        classif.estimators_[1], min_x, max_x, "k-.", "Boundary\nfor class 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("First principal component")
        plt.ylabel("Second principal component")
        plt.legend(loc="upper left")

Génération du jeu de données

Dans cette étape, nous générons le jeu de données à l'aide de la fonction make_multilabel_classification de sklearn.datasets.

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

Tracer les sous-graphiques

Dans cette étape, nous utilisons la fonction plot_subfigure pour tracer les sous-graphiques.

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

plot_subfigure(X, Y, 1, "Avec des échantillons non étiquetés + CCA", "cca")
plot_subfigure(X, Y, 2, "Avec des échantillons non étiquetés + PCA", "pca")

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

plot_subfigure(X, Y, 3, "Sans des échantillons non étiquetés + CCA", "cca")
plot_subfigure(X, Y, 4, "Sans des échantillons non étiquetés + PCA", "pca")

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

Sommaire

Ce laboratoire a démontré un problème de classification de documents multi-étiquette à l'aide de scikit-learn. Nous avons utilisé la fonction make_multilabel_classification pour générer le jeu de données et la fonction plot_subfigure pour tracer les sous-graphiques.