Column Transformer de Scikit-Learn

Introduction

Dans ce laboratoire, nous allons apprendre à utiliser ColumnTransformer de Scikit-Learn sur un ensemble de données qui contient différents types de fonctionnalités. Cette technique est utile lorsqu'un ensemble de données contient des composants qui nécessitent des pipelines d'extraction et de traitement de fonctionnalités différents.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour passer à l'onglet Carnet de notes pour accéder au carnet Jupyter pour la pratique.

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

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

Ensemble de données

Nous utiliserons l'ensemble de données 20 newsgroups, qui est composé de messages de groupes de discussion sur 20 sujets. L'ensemble de données est divisé en sous-ensembles d'entraînement et de test en fonction des messages postés avant et après une date spécifique. Nous n'utiliserons que les messages de 2 catégories pour accélérer le temps d'exécution.

categories = ["sci.med", "sci.space"]
X_train, y_train = fetch_20newsgroups(
    random_state=1,
    subset="train",
    categories=categories,
    remove=("footers", "quotes"),
    return_X_y=True,
)
X_test, y_test = fetch_20newsgroups(
    random_state=1,
    subset="test",
    categories=categories,
    remove=("footers", "quotes"),
    return_X_y=True,
)

Création de transformateurs

Nous allons créer des transformateurs qui extraient des fonctionnalités à partir de l'ensemble de données. Nous allons définir deux fonctions qui effectuent la transformation des données puis utiliser FunctionTransformer de Scikit-Learn pour créer des transformateurs.

def subject_body_extractor(posts):
    ## construct object dtype array with two columns
    ## first column = 'subject' and second column = 'body'
    features = np.empty(shape=(len(posts), 2), dtype=object)
    for i, text in enumerate(posts):
        ## temporary variable `_` stores '\n\n'
        headers, _, body = text.partition("\n\n")
        ## store body text in second column
        features[i, 1] = body

        prefix = "Subject:"
        sub = ""
        ## save text after 'Subject:' in first column
        for line in headers.split("\n"):
            if line.startswith(prefix):
                sub = line[len(prefix) :]
                break
        features[i, 0] = sub

    return features

subject_body_transformer = FunctionTransformer(subject_body_extractor)

def text_stats(posts):
    return [{"length": len(text), "num_sentences": text.count(".")} for text in posts]

text_stats_transformer = FunctionTransformer(text_stats)

Pipeline de classification

Nous allons créer un pipeline qui extrait des fonctionnalités à partir de l'ensemble de données, les combine et entraîne un classifieur sur l'ensemble combiné de fonctionnalités. Nous utiliserons Pipeline et ColumnTransformer de Scikit-Learn pour y arriver.

pipeline = Pipeline(
    [
        ## Extract subject & body
        ("subjectbody", subject_body_transformer),
        ## Use ColumnTransformer to combine the subject and body features
        (
            "union",
            ColumnTransformer(
                [
                    ## bag-of-words for subject (col 0)
                    ("subject", TfidfVectorizer(min_df=50), 0),
                    ## bag-of-words with decomposition for body (col 1)
                    (
                        "body_bow",
                        Pipeline(
                            [
                                ("tfidf", TfidfVectorizer()),
                                ("best", TruncatedSVD(n_components=50)),
                            ]
                        ),
                        1,
                    ),
                    ## Pipeline for pulling text stats from post's body
                    (
                        "body_stats",
                        Pipeline(
                            [
                                (
                                    "stats",
                                    text_stats_transformer,
                                ),  ## returns a list of dicts
                                (
                                    "vect",
                                    DictVectorizer(),
                                ),  ## list of dicts -> feature matrix
                            ]
                        ),
                        1,
                    ),
                ],
                ## weight above ColumnTransformer features
                transformer_weights={
                    "subject": 0.8,
                    "body_bow": 0.5,
                    "body_stats": 1.0,
                },
            ),
        ),
        ## Use a SVC classifier on the combined features
        ("svc", LinearSVC(dual=False)),
    ],
    verbose=True,
)

Entraînement et test

Nous allons ajuster notre pipeline sur les données d'entraînement et l'utiliser pour prédire les sujets pour X_test. Les métriques de performance de notre pipeline sont ensuite affichées.

pipeline.fit(X_train, y_train)
y_pred = pipeline.predict(X_test)
print("Classification report:\n\n{}".format(classification_report(y_test, y_pred)))

Résumé

Dans ce laboratoire, nous avons appris à utiliser ColumnTransformer de Scikit-Learn sur un ensemble de données contenant différents types de fonctionnalités. Nous avons créé des transformateurs qui ont extrait des fonctionnalités à partir de l'ensemble de données et les avons utilisées pour entraîner un classifieur sur l'ensemble combiné de fonctionnalités. ColumnTransformer nous a permis de traiter les différents types de fonctionnalités dans un seul pipeline.