Vorverarbeitung und Feature-Extraktionspipelines | Titanic-Datensatz

Einführung

In diesem Lab wird gezeigt, wie verschiedene Aufbereitungs- und Merkmalsgewinnungspipelines auf verschiedene Teilmengen von Merkmalen angewendet werden können, indem ColumnTransformer verwendet wird. Dies ist besonders nützlich bei Datensätzen, die heterogene Datentypen enthalten, da wir möglicherweise die numerischen Merkmale skalieren und die kategorischen Merkmale mit One-Hot-Codierung versehen möchten.

In diesem Lab verwenden wir den Titanic-Datensatz von OpenML, um eine Pipeline zu erstellen, die sowohl kategorische als auch numerische Daten mit ColumnTransformer aufbereitet und diese verwendet, um ein logistisches Regressionsmodell zu trainieren.

Tipps für die VM

Nachdem der VM-Start abgeschlossen ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu öffnen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund der Einschränkungen in Jupyter Notebook nicht automatisiert werden.

Wenn Sie bei der Lernphase Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.

Bibliotheken importieren

In diesem Schritt importieren wir die erforderlichen Bibliotheken für das Erstellen unserer Pipeline.

import numpy as np
from sklearn.compose import ColumnTransformer
from sklearn.datasets import fetch_openml
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split, RandomizedSearchCV
from sklearn.feature_selection import SelectPercentile, chi2

Lade den Datensatz

In diesem Schritt laden wir den Titanic-Datensatz von OpenML mit fetch_openml.

X, y = fetch_openml(
    "titanic", version=1, as_frame=True, return_X_y=True, parser="pandas"
)

Definiere numerische und kategorische Merkmale

In diesem Schritt definieren wir die numerischen und kategorischen Merkmale, die wir für unsere Pipeline verwenden werden. Wir definieren auch die Aufbereitungspipelines für sowohl numerische als auch kategorische Daten.

numeric_features = ["age", "fare"]
numeric_transformer = Pipeline(
    steps=[("imputer", SimpleImputer(strategy="median")), ("scaler", StandardScaler())]
)

categorical_features = ["embarked", "sex", "pclass"]
categorical_transformer = Pipeline(
    steps=[
        ("encoder", OneHotEncoder(handle_unknown="ignore")),
        ("selector", SelectPercentile(chi2, percentile=50)),
    ]
)

Definiere den Vorverarbeiter

In diesem Schritt definieren wir den ColumnTransformer, der zur Vorverarbeitung unserer Daten verwendet werden wird.

preprocessor = ColumnTransformer(
    transformers=[
        ("num", numeric_transformer, numeric_features),
        ("cat", categorical_transformer, categorical_features),
    ]
)

Füge den Klassifizierer zur Vorverarbeitungspipeline hinzu

In diesem Schritt fügen wir den logistischen Regressionsklassifizierer zu unserer Vorverarbeitungspipeline hinzu, indem wir Pipeline verwenden.

clf = Pipeline(
    steps=[("preprocessor", preprocessor), ("classifier", LogisticRegression())]
)

Teile die Daten auf

In diesem Schritt teilen wir unsere Daten in Trainings- und Testsets auf, indem wir train_test_split verwenden.

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

Passt die Pipeline an

In diesem Schritt passen wir unsere Pipeline an unsere Trainingsdaten an.

clf.fit(X_train, y_train)

#计算管道的性能

在这一步中，我们将通过计算模型得分来评估管道的性能。

print("model score: %.3f" % clf.score(X_test, y_test))

Verwende ColumnTransformer, um Spalten nach Datentypen auszuwählen

In diesem Schritt werden wir ColumnTransformer verwenden, um Spalten nach Datentypen auszuwählen. Wir werden make_column_selector verwenden, um Spalten basierend auf ihren Datentypen auszuwählen.

from sklearn.compose import make_column_selector as selector

subset_feature = ["embarked", "sex", "pclass", "age", "fare"]
X_train, X_test = X_train[subset_feature], X_test[subset_feature]

preprocessor = ColumnTransformer(
    transformers=[
        ("num", numeric_transformer, selector(dtype_exclude="category")),
        ("cat", categorical_transformer, selector(dtype_include="category")),
    ]
)
clf = Pipeline(
    steps=[("preprocessor", preprocessor), ("classifier", LogisticRegression())]
)

Verwende das Grid Search, um die Hyperparameter zu optimieren

In diesem Schritt werden wir das Grid Search verwenden, um die Hyperparameter unserer Pipeline zu optimieren.

param_grid = {
    "preprocessor__num__imputer__strategy": ["mean", "median"],
    "preprocessor__cat__selector__percentile": [10, 30, 50, 70],
    "classifier__C": [0.1, 1.0, 10, 100],
}

search_cv = RandomizedSearchCV(clf, param_grid, n_iter=10, random_state=0)
search_cv.fit(X_train, y_train)

print("Best params:")
print(search_cv.best_params_)
print(f"Internal CV score: {search_cv.best_score_:.3f}")

Zusammenfassung

In diesem Lab haben wir gelernt, wie man ColumnTransformer verwendet, um kategorische und numerische Daten in einer Pipeline vorzuverarbeiten, und wie man das Grid Search verwendet, um die Hyperparameter unserer Pipeline zu optimieren.

Column Transformer mit gemischten Datentypen