7.1. Pipelines und zusammengesetzte Estimators#

Um einen zusammengesetzten Estimator zu erstellen, werden Transformer normalerweise mit anderen Transformern oder mit Predictoren (wie Klassifikatoren oder Regressoren) kombiniert. Das gängigste Werkzeug zum Kombinieren von Estimators ist eine Pipeline. Pipelines verlangen, dass alle Schritte außer dem letzten ein Transformer sind. Der letzte Schritt kann alles sein, ein Transformer, ein Predictor oder ein Clustering-Estimator, der möglicherweise über eine .predict(...) Methode verfügt oder auch nicht. Eine Pipeline exponiert alle Methoden, die vom letzten Estimator bereitgestellt werden: Wenn der letzte Schritt eine transform Methode bereitstellt, dann hat die Pipeline eine transform Methode und verhält sich wie ein Transformer. Wenn der letzte Schritt eine predict Methode bereitstellt, dann exponiert die Pipeline diese Methode und verwendet unter Angabe von Daten X alle Schritte außer dem letzten, um die Daten zu transformieren, und gibt diese transformierten Daten dann an die predict Methode des letzten Schritts der Pipeline weiter. Die Klasse Pipeline wird oft in Kombination mit ColumnTransformer oder FeatureUnion verwendet, die die Ausgaben von Transformern zu einem zusammengesetzten Merkmalsraum verketten. TransformedTargetRegressor kümmert sich um die Transformation des Targets (d.h. Log-Transformation von y).

7.1.1. Pipeline: Verkettung von Estimators#

Eine Pipeline kann verwendet werden, um mehrere Estimators zu einer einzigen zusammenzufassen. Dies ist nützlich, da bei der Verarbeitung von Daten oft eine feste Abfolge von Schritten besteht, z. B. Merkmalsauswahl, Normalisierung und Klassifizierung. Die Pipeline dient hier mehreren Zwecken:

Komfort und Kapselung: Sie müssen nur einmal fit und predict auf Ihren Daten aufrufen, um eine ganze Sequenz von Estimators anzupassen.
Gemeinsame Parameterwahl: Sie können Parameter aller Estimators in der Pipeline auf einmal in einem Grid Search durchsuchen.
Sicherheit: Pipelines helfen, das Überlaufen von Statistiken aus Ihren Testdaten in das trainierte Modell bei der Kreuzvalidierung zu vermeiden, indem sichergestellt wird, dass dieselben Stichproben zum Trainieren der Transformer und Predictoren verwendet werden.

Alle Estimators in einer Pipeline, außer dem letzten, müssen Transformer sein (d.h. sie müssen eine transform Methode haben). Der letzte Estimator kann jeder Typ sein (Transformer, Klassifikator usw.).

Hinweis

Das Aufrufen von fit auf der Pipeline entspricht dem Aufrufen von fit auf jedem Estimator der Reihe nach, dem Transformieren der Eingabe und der Weitergabe an den nächsten Schritt. Die Pipeline hat alle Methoden, die der letzte Estimator in der Pipeline hat, d.h. wenn der letzte Estimator ein Klassifikator ist, kann die Pipeline als Klassifikator verwendet werden. Wenn der letzte Estimator ein Transformer ist, ist die Pipeline ebenfalls einer.

7.1.1.1. Verwendung#

7.1.1.1.1. Erstellen einer Pipeline#

Die Pipeline wird mithilfe einer Liste von (Schlüssel, Wert)-Paaren erstellt, wobei der Schlüssel ein String ist, der den Namen enthält, den Sie diesem Schritt geben möchten, und der Wert ein Estimator-Objekt ist.

>>> from sklearn.pipeline import Pipeline
>>> from sklearn.svm import SVC
>>> from sklearn.decomposition import PCA
>>> estimators = [('reduce_dim', PCA()), ('clf', SVC())]
>>> pipe = Pipeline(estimators)
>>> pipe
Pipeline(steps=[('reduce_dim', PCA()), ('clf', SVC())])

7.1.1.1.2. Zugriff auf Pipeline-Schritte#

Die Estimators einer Pipeline werden als Liste im Attribut steps gespeichert. Eine Teil-Pipeline kann mithilfe der Slice-Notation, die üblicherweise für Python-Sequenzen wie Listen oder Strings verwendet wird (obwohl nur ein Schritt der Länge 1 zulässig ist), extrahiert werden. Dies ist praktisch, um nur einige der Transformationen (oder ihre Umkehrungen) durchzuführen.

>>> pipe[:1]
Pipeline(steps=[('reduce_dim', PCA())])
>>> pipe[-1:]
Pipeline(steps=[('clf', SVC())])

7.1.1.1.3. Nachverfolgen von Merkmalsnamen in einer Pipeline#

Um die Modellinspektion zu ermöglichen, verfügt die Pipeline, genau wie alle Transformer, über eine Methode get_feature_names_out(). Sie können Pipeline-Slicing verwenden, um die Merkmalsnamen zu erhalten, die in jeden Schritt eingehen.

>>> from sklearn.datasets import load_iris
>>> from sklearn.linear_model import LogisticRegression
>>> from sklearn.feature_selection import SelectKBest
>>> iris = load_iris()
>>> pipe = Pipeline(steps=[
...    ('select', SelectKBest(k=2)),
...    ('clf', LogisticRegression())])
>>> pipe.fit(iris.data, iris.target)
Pipeline(steps=[('select', SelectKBest(...)), ('clf', LogisticRegression(...))])
>>> pipe[:-1].get_feature_names_out()
array(['x2', 'x3'], ...)

7.1.1.1.4. Zugriff auf verschachtelte Parameter#

Es ist üblich, die Parameter eines Estimators innerhalb einer Pipeline anzupassen. Dieser Parameter ist daher verschachtelt, da er zu einem bestimmten Unterschritt gehört. Parameter von Estimators in der Pipeline sind über die Syntax <estimator>__<parameter> zugänglich.

>>> pipe = Pipeline(steps=[("reduce_dim", PCA()), ("clf", SVC())])
>>> pipe.set_params(clf__C=10)
Pipeline(steps=[('reduce_dim', PCA()), ('clf', SVC(C=10))])

Beispiele

7.1.1.2. Caching von Transformern: Vermeidung wiederholter Berechnungen#

Das Anpassen von Transformern kann rechenintensiv sein. Mit seinem memory Parameter speichert Pipeline jeden Transformer nach dem Aufruf von fit zwischen. Diese Funktion wird verwendet, um die Anpassung von Transformern innerhalb einer Pipeline zu vermeiden, wenn die Parameter und die Eingabedaten identisch sind. Ein typisches Beispiel ist der Fall einer Grid Search, bei der die Transformer nur einmal angepasst und für jede Konfiguration wiederverwendet werden können. Der letzte Schritt wird niemals gecacht, auch wenn er ein Transformer ist.

Der Parameter memory ist erforderlich, um die Transformer zu cachen. memory kann entweder ein String sein, der das Verzeichnis enthält, in dem die Transformer gecacht werden sollen, oder ein joblib.Memory-Objekt.

>>> from tempfile import mkdtemp
>>> from shutil import rmtree
>>> from sklearn.decomposition import PCA
>>> from sklearn.svm import SVC
>>> from sklearn.pipeline import Pipeline
>>> estimators = [('reduce_dim', PCA()), ('clf', SVC())]
>>> cachedir = mkdtemp()
>>> pipe = Pipeline(estimators, memory=cachedir)
>>> pipe
Pipeline(memory=...,
         steps=[('reduce_dim', PCA()), ('clf', SVC())])
>>> # Clear the cache directory when you don't need it anymore
>>> rmtree(cachedir)

Beispiele

Dimensionsreduktion auswählen mit Pipeline und GridSearchCV

7.1.2. Transformation des Targets bei Regression#

Der TransformedTargetRegressor transformiert die Targets y, bevor ein Regressionsmodell angepasst wird. Die Vorhersagen werden über eine Umkehrtransformation zurück in den ursprünglichen Raum abgebildet. Er nimmt als Argument den Regressor, der für die Vorhersage verwendet wird, und den Transformer, der auf die Zielvariable angewendet wird.

>>> import numpy as np
>>> from sklearn.datasets import make_regression
>>> from sklearn.compose import TransformedTargetRegressor
>>> from sklearn.preprocessing import QuantileTransformer
>>> from sklearn.linear_model import LinearRegression
>>> from sklearn.model_selection import train_test_split
>>> # create a synthetic dataset
>>> X, y = make_regression(n_samples=20640,
...                        n_features=8,
...                        noise=100.0,
...                        random_state=0)
>>> y = np.exp( 1 + (y - y.min()) * (4 / (y.max() - y.min())))
>>> X, y = X[:2000, :], y[:2000]  # select a subset of data
>>> transformer = QuantileTransformer(output_distribution='normal')
>>> regressor = LinearRegression()
>>> regr = TransformedTargetRegressor(regressor=regressor,
...                                   transformer=transformer)
>>> X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
>>> regr.fit(X_train, y_train)
TransformedTargetRegressor(...)
>>> print(f"R2 score: {regr.score(X_test, y_test):.2f}")
R2 score: 0.67
>>> raw_target_regr = LinearRegression().fit(X_train, y_train)
>>> print(f"R2 score: {raw_target_regr.score(X_test, y_test):.2f}")
R2 score: 0.64

Für einfache Transformationen können anstelle eines Transformer-Objekts ein Paar von Funktionen übergeben werden, die die Transformation und ihre Umkehrabbildung definieren.

>>> def func(x):
...     return np.log(x)
>>> def inverse_func(x):
...     return np.exp(x)

Anschließend wird das Objekt erstellt als

>>> regr = TransformedTargetRegressor(regressor=regressor,
...                                   func=func,
...                                   inverse_func=inverse_func)
>>> regr.fit(X_train, y_train)
TransformedTargetRegressor(...)
>>> print(f"R2 score: {regr.score(X_test, y_test):.2f}")
R2 score: 0.67

Standardmäßig wird bei jedem Fit überprüft, ob die bereitgestellten Funktionen die Umkehrungen voneinander sind. Es ist jedoch möglich, diese Prüfung zu umgehen, indem check_inverse auf False gesetzt wird.

>>> def inverse_func(x):
...     return x
>>> regr = TransformedTargetRegressor(regressor=regressor,
...                                   func=func,
...                                   inverse_func=inverse_func,
...                                   check_inverse=False)
>>> regr.fit(X_train, y_train)
TransformedTargetRegressor(...)
>>> print(f"R2 score: {regr.score(X_test, y_test):.2f}")
R2 score: -3.02

Hinweis

Die Transformation kann durch Setzen von entweder transformer oder dem Paar von Funktionen func und inverse_func ausgelöst werden. Das Setzen beider Optionen führt jedoch zu einem Fehler.

Beispiele

Auswirkung der Transformation der Ziele in einem Regressionsmodell

7.1.3. FeatureUnion: Zusammengesetzte Merkmalsräume#

Die FeatureUnion kombiniert mehrere Transformer-Objekte zu einem neuen Transformer, der ihre Ausgaben kombiniert. Eine FeatureUnion nimmt eine Liste von Transformer-Objekten entgegen. Während des Anpassens wird jeder dieser Transformer unabhängig von den Daten angepasst. Die Transformer werden parallel angewendet, und die von ihnen ausgegebenen Merkmalsmatrizen werden nebeneinander zu einer größeren Matrix verkettet.

Wenn Sie unterschiedliche Transformationen auf jedes Feld der Daten anwenden möchten, siehe die verwandte Klasse ColumnTransformer (siehe Benutzerhandbuch).

Die FeatureUnion dient denselben Zwecken wie die Pipeline – Komfort und gemeinsame Parameterschätzung und -validierung.

Die FeatureUnion und die Pipeline können kombiniert werden, um komplexe Modelle zu erstellen.

(Eine FeatureUnion hat keine Möglichkeit zu überprüfen, ob zwei Transformer identische Merkmale erzeugen könnten. Sie erzeugt nur eine Vereinigung, wenn die Merkmalsmengen disjunkt sind, und die Sicherstellung, dass sie disjunkt sind, liegt in der Verantwortung des Aufrufers.)

7.1.3.1. Verwendung#

Eine FeatureUnion wird mithilfe einer Liste von (Schlüssel, Wert)-Paaren erstellt, wobei der Schlüssel der Name ist, den Sie einer bestimmten Transformation geben möchten (eine beliebige Zeichenkette; er dient nur als Identifikator), und der Wert ein Estimator-Objekt ist.

>>> from sklearn.pipeline import FeatureUnion
>>> from sklearn.decomposition import PCA
>>> from sklearn.decomposition import KernelPCA
>>> estimators = [('linear_pca', PCA()), ('kernel_pca', KernelPCA())]
>>> combined = FeatureUnion(estimators)
>>> combined
FeatureUnion(transformer_list=[('linear_pca', PCA()),
                               ('kernel_pca', KernelPCA())])

Wie Pipelines haben Feature Unions einen Kurzform-Konstruktor namens make_union, der keine explizite Benennung der Komponenten erfordert.

Wie Pipeline können einzelne Schritte mithilfe von set_params ersetzt und ignoriert werden, indem sie auf 'drop' gesetzt werden.

>>> combined.set_params(kernel_pca='drop')
FeatureUnion(transformer_list=[('linear_pca', PCA()),
                               ('kernel_pca', 'drop')])

Beispiele

Verkettung mehrerer Merkmalsextraktionsmethoden

7.1.4. ColumnTransformer für heterogene Daten#

Viele Datensätze enthalten Merkmale unterschiedlicher Typen, z. B. Text, Floats und Daten, wobei jeder Merkmalstyp separate Vorverarbeitungs- oder Merkmalsextraktionsschritte erfordert. Oft ist es am einfachsten, Daten vor der Anwendung von scikit-learn-Methoden vorzuverarbeiten, z. B. mithilfe von pandas. Die Verarbeitung Ihrer Daten, bevor Sie sie an scikit-learn übergeben, kann aus einem der folgenden Gründe problematisch sein:

Die Einbeziehung von Statistiken aus Testdaten in die Präprozessoren macht Kreuzvalidierungsergebnisse unzuverlässig (bekannt als Datenlecks), z. B. bei Skalierern oder der Imputation fehlender Werte.
Sie möchten möglicherweise die Parameter der Präprozessoren in eine Parametersuche aufnehmen.

Der ColumnTransformer hilft bei der Durchführung unterschiedlicher Transformationen für verschiedene Spalten der Daten, innerhalb einer Pipeline, die sicher vor Datenlecks ist und parametrisiert werden kann. ColumnTransformer arbeitet mit Arrays, Sparse-Matrizen und pandas DataFrames.

Für jede Spalte kann eine andere Transformation angewendet werden, z. B. Vorverarbeitung oder eine spezifische Merkmalsextraktionsmethode.

>>> import pandas as pd
>>> X = pd.DataFrame(
...     {'city': ['London', 'London', 'Paris', 'Sallisaw'],
...      'title': ["His Last Bow", "How Watson Learned the Trick",
...                "A Moveable Feast", "The Grapes of Wrath"],
...      'expert_rating': [5, 3, 4, 5],
...      'user_rating': [4, 5, 4, 3]})

Für diese Daten möchten wir möglicherweise die Spalte 'city' mithilfe von OneHotEncoder als kategorische Variable kodieren, aber eine CountVectorizer auf die Spalte 'title' anwenden. Da wir mehrere Merkmalsextraktionsmethoden auf dieselbe Spalte anwenden könnten, geben wir jedem Transformer einen eindeutigen Namen, z. B. 'city_category' und 'title_bow'. Standardmäßig werden die verbleibenden Bewertungsspalten ignoriert (remainder='drop').

>>> from sklearn.compose import ColumnTransformer
>>> from sklearn.feature_extraction.text import CountVectorizer
>>> from sklearn.preprocessing import OneHotEncoder
>>> column_trans = ColumnTransformer(
...     [('categories', OneHotEncoder(dtype='int'), ['city']),
...      ('title_bow', CountVectorizer(), 'title')],
...     remainder='drop', verbose_feature_names_out=False)

>>> column_trans.fit(X)
ColumnTransformer(transformers=[('categories', OneHotEncoder(dtype='int'),
                                 ['city']),
                                ('title_bow', CountVectorizer(), 'title')],
                  verbose_feature_names_out=False)

>>> column_trans.get_feature_names_out()
array(['city_London', 'city_Paris', 'city_Sallisaw', 'bow', 'feast',
'grapes', 'his', 'how', 'last', 'learned', 'moveable', 'of', 'the',
 'trick', 'watson', 'wrath'], ...)

>>> column_trans.transform(X).toarray()
array([[1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0],
       [1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0],
       [0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
       [0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1]]...)

Im obigen Beispiel erwartet die CountVectorizer ein 1D-Array als Eingabe und daher wurden die Spalten als String ('title') angegeben. Die OneHotEncoder erwartet jedoch, wie die meisten anderen Transformer, 2D-Daten, daher müssen Sie in diesem Fall die Spalte als Liste von Strings (['city']) angeben.

Neben einem Skalar oder einer einzelnen Elementliste kann die Spaltenauswahl als Liste mehrerer Elemente, ein Integer-Array, ein Slice, eine boolesche Maske oder mit einem make_column_selector angegeben werden. Der make_column_selector wird verwendet, um Spalten basierend auf Datentyp oder Spaltennamen auszuwählen.

>>> from sklearn.preprocessing import StandardScaler
>>> from sklearn.compose import make_column_selector
>>> ct = ColumnTransformer([
...       ('scale', StandardScaler(),
...       make_column_selector(dtype_include=np.number)),
...       ('onehot',
...       OneHotEncoder(),
...       make_column_selector(pattern='city', dtype_include=[object, "string"]))])
>>> ct.fit_transform(X)
array([[ 0.904,  0.      ,  1. ,  0. ,  0. ],
       [-1.507,  1.414,  1. ,  0. ,  0. ],
       [-0.301,  0.      ,  0. ,  1. ,  0. ],
       [ 0.904, -1.414,  0. ,  0. ,  1. ]])

Strings können Spalten referenzieren, wenn die Eingabe ein DataFrame ist, Integer werden immer als positionelle Spalten interpretiert.

Wir können die verbleibenden Bewertungsspalten behalten, indem wir remainder='passthrough' setzen. Die Werte werden am Ende der Transformation angehängt.

>>> column_trans = ColumnTransformer(
...     [('city_category', OneHotEncoder(dtype='int'),['city']),
...      ('title_bow', CountVectorizer(), 'title')],
...     remainder='passthrough')

>>> column_trans.fit_transform(X)
array([[1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 5, 4],
       [1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 3, 5],
       [0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 4, 4],
       [0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 5, 3]]...)

Der Parameter remainder kann auf einen Estimator gesetzt werden, um die verbleibenden Bewertungsspalten zu transformieren. Die transformierten Werte werden am Ende der Transformation angehängt.

>>> from sklearn.preprocessing import MinMaxScaler
>>> column_trans = ColumnTransformer(
...     [('city_category', OneHotEncoder(), ['city']),
...      ('title_bow', CountVectorizer(), 'title')],
...     remainder=MinMaxScaler())

>>> column_trans.fit_transform(X)[:, -2:]
array([[1. , 0.5],
       [0. , 1. ],
       [0.5, 0.5],
       [1. , 0. ]])

Die Funktion make_column_transformer ist verfügbar, um einfacher ein ColumnTransformer-Objekt zu erstellen. Insbesondere werden die Namen automatisch vergeben. Das Äquivalent zum obigen Beispiel wäre:

>>> from sklearn.compose import make_column_transformer
>>> column_trans = make_column_transformer(
...     (OneHotEncoder(), ['city']),
...     (CountVectorizer(), 'title'),
...     remainder=MinMaxScaler())
>>> column_trans
ColumnTransformer(remainder=MinMaxScaler(),
                  transformers=[('onehotencoder', OneHotEncoder(), ['city']),
                                ('countvectorizer', CountVectorizer(),
                                 'title')])

Wenn ColumnTransformer mit einem DataFrame angepasst wird und der DataFrame nur Spaltennamen als Strings hat, dann verwendet die Transformation eines DataFrames die Spaltennamen zur Auswahl der Spalten.

>>> ct = ColumnTransformer(
...          [("scale", StandardScaler(), ["expert_rating"])]).fit(X)
>>> X_new = pd.DataFrame({"expert_rating": [5, 6, 1],
...                       "ignored_new_col": [1.2, 0.3, -0.1]})
>>> ct.transform(X_new)
array([[ 0.9],
       [ 2.1],
       [-3.9]])

7.1.5. Visualisierung von zusammengesetzten Estimators#

Estimators werden mit einer HTML-Darstellung angezeigt, wenn sie in einem Jupyter-Notebook angezeigt werden. Dies ist nützlich, um eine Pipeline mit vielen Estimators zu diagnostizieren oder zu visualisieren. Diese Visualisierung ist standardmäßig aktiviert.

>>> column_trans

Sie kann deaktiviert werden, indem die Option display in set_config auf 'text' gesetzt wird.

>>> from sklearn import set_config
>>> set_config(display='text')
>>> # displays text representation in a jupyter context
>>> column_trans

Ein Beispiel für die HTML-Ausgabe ist im Abschnitt HTML-Darstellung von Pipeline von Column Transformer mit gemischten Typen zu sehen. Alternativ kann das HTML mit estimator_html_repr in eine Datei geschrieben werden.

>>> from sklearn.utils import estimator_html_repr
>>> with open('my_estimator.html', 'w') as f:
...     f.write(estimator_html_repr(clf))

Beispiele

7.1. Pipelines und zusammengesetzte Estimators#

7.1.1. Pipeline: Verkettung von Estimators#

7.1.1.1. Verwendung#

7.1.1.1.1. Erstellen einer Pipeline#

7.1.1.1.2. Zugriff auf Pipeline-Schritte#

7.1.1.1.3. Nachverfolgen von Merkmalsnamen in einer Pipeline#

7.1.1.1.4. Zugriff auf verschachtelte Parameter#

7.1.1.2. Caching von Transformern: Vermeidung wiederholter Berechnungen#

7.1.2. Transformation des Targets bei Regression#

7.1.3. FeatureUnion: Zusammengesetzte Merkmalsräume#

7.1.3.1. Verwendung#

7.1.4. ColumnTransformer für heterogene Daten#

7.1.5. Visualisierung von zusammengesetzten Estimators#

Diese Seite