Extraction et évaluation des caractéristiques textuelles

Introduction

La bibliothèque scikit-learn fournit des outils pour l'extraction de caractéristiques de texte et l'évaluation. Dans ce laboratoire, nous utiliserons l'ensemble de données 20newsgroups pour démontrer comment extraire des caractéristiques à partir de données textuelles, construire un pipeline et évaluer les performances du modèle en utilisant l'ajustement d'hyperparamètres.

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 des commentaires après la session, et nous résoudrons rapidement le problème pour vous.

Skills Graph

Charger les données

Nous allons charger l'ensemble de données 20newsgroups qui est une collection d'environ 20 000 documents de newsgroup répartis en 20 catégories différentes. Pour ce laboratoire, nous nous concentrerons sur deux catégories : alt.atheism et talk.religion.misc.

from sklearn.datasets import fetch_20newsgroups

categories = [
    "alt.atheism",
    "talk.religion.misc",
]

data_train = fetch_20newsgroups(
    subset="train",
    categories=categories,
    shuffle=True,
    random_state=42,
    remove=("headers", "footers", "quotes"),
)

data_test = fetch_20newsgroups(
    subset="test",
    categories=categories,
    shuffle=True,
    random_state=42,
    remove=("headers", "footers", "quotes"),
)

print(f"Chargement de l'ensemble de données 20 newsgroups pour {len(data_train.target_names)} catégories :")
print(data_train.target_names)
print(f"{len(data_train.data)} documents")

Définir un pipeline avec l'ajustement d'hyperparamètres

Nous définissons un pipeline qui combine un vectoriseur de caractéristiques de texte avec un classifieur simple pour la classification de texte. Nous utiliserons le classifieur Complement Naive Bayes et le TfidfVectorizer pour l'extraction de caractéristiques.

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import ComplementNB
from sklearn.pipeline import Pipeline
import numpy as np

pipeline = Pipeline(
    [
        ("vect", TfidfVectorizer()),
        ("clf", ComplementNB()),
    ]
)

parameter_grid = {
    "vect__max_df": (0.2, 0.4, 0.6, 0.8, 1.0),
    "vect__min_df": (1, 3, 5, 10),
    "vect__ngram_range": ((1, 1), (1, 2)),  ## unigrams ou bigrams
    "vect__norm": ("l1", "l2"),
    "clf__alpha": np.logspace(-6, 6, 13),
}

Ajustement d'hyperparamètres

Nous utilisons RandomizedSearchCV pour explorer la grille d'hyperparamètres et trouver la meilleure combinaison d'hyperparamètres pour le pipeline. Dans ce cas, nous définissons n_iter = 40 pour limiter l'espace de recherche. Nous pouvons augmenter n_iter pour obtenir une analyse plus informative, mais cela augmentera le temps de calcul.

from sklearn.model_selection import RandomizedSearchCV

random_search = RandomizedSearchCV(
    estimator=pipeline,
    param_distributions=parameter_grid,
    n_iter=40,
    random_state=0,
    n_jobs=2,
    verbose=1,
)

print("Effectuer une recherche sur grille...")
print("Hyperparamètres à évaluer :")
pprint(parameter_grid)

random_search.fit(data_train.data, data_train.target)

test_accuracy = random_search.score(data_test.data, data_test.target)

Visualisation des résultats

Nous pouvons visualiser les résultats de l'ajustement d'hyperparamètres à l'aide de plotly.express. Nous utilisons un graphique en points pour visualiser le compromis entre le temps de calcul de la notation et la moyenne du score de test. Nous pouvons également utiliser des coordonnées parallèles pour visualiser en outre la moyenne du score de test en fonction des hyperparamètres ajustés.

import pandas as pd
import plotly.express as px
import math

def shorten_param(param_name):
    """Supprime les préfixes des composants dans param_name."""
    if "__" est dans param_name:
        return param_name.rsplit("__", 1)[1]
    return param_name

cv_results = pd.DataFrame(random_search.cv_results_)
cv_results = cv_results.rename(shorten_param, axis=1)

param_names = [shorten_param(name) for name in parameter_grid.keys()]
labels = {
    "mean_score_time": "Temps de notation CV (s)",
    "mean_test_score": "Score CV (précision)",
}
fig = px.scatter(
    cv_results,
    x="mean_score_time",
    y="mean_test_score",
    error_x="std_score_time",
    error_y="std_test_score",
    hover_data=param_names,
    labels=labels,
)

fig.update_layout(
    title={
        "text": "Compromis entre le temps de notation et la moyenne du score de test",
        "y": 0.95,
        "x": 0.5,
        "xanchor": "center",
        "yanchor": "top",
    }
)

column_results = param_names + ["mean_test_score", "mean_score_time"]

transform_funcs = dict.fromkeys(column_results, lambda x: x)
## Utilisation d'une échelle logarithmique pour alpha
transform_funcs["alpha"] = math.log10
## Les normes L1 sont mappées à l'index 1 et les normes L2 à l'index 2
transform_funcs["norm"] = lambda x: 2 if x == "l2" else 1
## Les unigrammes sont mappés à l'index 1 et les bigrammes à l'index 2
transform_funcs["ngram_range"] = lambda x: x[1]

fig = px.parallel_coordinates(
    cv_results[column_results].apply(transform_funcs),
    color="mean_test_score",
    color_continuous_scale=px.colors.sequential.Viridis_r,
    labels=labels,
)
fig.update_layout(
    title={
        "text": "Représentation en coordonnées parallèles du pipeline de classification de texte",
        "y": 0.99,
        "x": 0.5,
        "xanchor": "center",
        "yanchor": "top",
    }
)

Sommaire

Dans ce laboratoire, nous avons démontré comment extraire des caractéristiques à partir de données textuelles, construire un pipeline et évaluer les performances du modèle en utilisant l'ajustement d'hyperparamètres. Nous avons utilisé l'ensemble de données 20newsgroups pour montrer comment utiliser RandomizedSearchCV pour trouver la meilleure combinaison d'hyperparamètres pour le pipeline et visualiser les résultats à l'aide de plotly.express.