Textdaten-Merkmalsextraktion und -Auswertung

Einführung

Die scikit-learn-Bibliothek bietet Werkzeuge zur Extraktion und Bewertung von Textmerkmalen. In diesem Lab werden wir den 20newsgroups-Datensatz verwenden, um zu zeigen, wie man Merkmale aus Textdaten extrahiert, eine Pipeline (Bearbeitungsreihenfolge) erstellt und die Leistung des Modells mithilfe von Hyperparameter-Tuning bewertet.

Tipps zur virtuellen Maschine (VM)

Nachdem die virtuelle Maschine 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 lösen.

Skills Graph

Daten laden

Wir werden den 20newsgroups-Datensatz laden, der eine Sammlung von ungefähr 20.000 Newsgroup-Dokumenten in 20 verschiedenen Kategorien ist. In diesem Lab werden wir uns auf zwei Kategorien konzentrieren: alt.atheism und 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"Loading 20 newsgroups dataset for {len(data_train.target_names)} categories:")
print(data_train.target_names)
print(f"{len(data_train.data)} documents")

Definition einer Pipeline (Bearbeitungsreihenfolge) mit Hyperparameter-Tuning

Wir definieren eine Pipeline, die einen Textmerkmal-Vektorisierer (text feature vectorizer) mit einem einfachen Klassifikator für die Textklassifizierung kombiniert. Wir werden Complement Naive Bayes als Klassifikator und TfidfVectorizer zur Merkmalsextraktion verwenden.

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 or bigrams
    "vect__norm": ("l1", "l2"),
    "clf__alpha": np.logspace(-6, 6, 13),
}

Hyperparameter-Tuning

Wir verwenden RandomizedSearchCV, um das Raster (Grid) der Hyperparameter zu erkunden und die beste Kombination von Hyperparametern für die Pipeline (Bearbeitungsreihenfolge) zu finden. In diesem Fall setzen wir n_iter=40, um den Suchraum zu begrenzen. Wir können n_iter erhöhen, um eine informativere Analyse zu erhalten, aber dies erhöht die Rechenzeit.

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("Performing grid search...")
print("Hyperparameters to be evaluated:")
pprint(parameter_grid)

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

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

Visualisierung der Ergebnisse

Wir können die Ergebnisse des Hyperparameter-Tunings mit plotly.express visualisieren. Wir verwenden ein Streudiagramm (Scatter Plot), um das Zusammenspiel zwischen der Bewertungszeit und der durchschnittlichen Testleistung zu visualisieren. Wir können auch Parallelkoordinaten verwenden, um die durchschnittliche Testleistung als Funktion der optimierten Hyperparameter weiter zu visualisieren.

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

def shorten_param(param_name):
    """Remove components' prefixes in param_name."""
    if "__" in 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": "CV Score time (s)",
    "mean_test_score": "CV score (accuracy)",
}
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": "trade-off between scoring time and mean test score",
        "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)
## Using a logarithmic scale for alpha
transform_funcs["alpha"] = math.log10
## L1 norms are mapped to index 1, and L2 norms to index 2
transform_funcs["norm"] = lambda x: 2 if x == "l2" else 1
## Unigrams are mapped to index 1 and bigrams to 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": "Parallel coordinates plot of text classifier pipeline",
        "y": 0.99,
        "x": 0.5,
        "xanchor": "center",
        "yanchor": "top",
    }
)

Zusammenfassung

In diesem Lab haben wir gezeigt, wie man Merkmale aus Textdaten extrahiert, eine Pipeline (Bearbeitungsreihenfolge) erstellt und die Leistung des Modells mithilfe von Hyperparameter-Tuning auswertet. Wir haben den 20newsgroups-Datensatz verwendet, um zu zeigen, wie man RandomizedSearchCV nutzt, um die beste Kombination von Hyperparametern für die Pipeline zu finden, und die Ergebnisse mit plotly.express visualisiert.