Sklearn-Pipeline
In Machine-Learning-Projekten sind Schritte wie Datenverarbeitung, Feature Engineering, Modelltraining und Evaluierung oft voneinander abhängig. Die Reihenfolge und Koordination dieser Schritte sind entscheidend für die Leistung des endgültigen Modells.
Pipeline ist ein wichtiges Werkzeug in scikit-learn, um diese Schritte zu organisieren und zu vereinfachen.
Durch Pipeline können wir die Datenvorverarbeitung mit dem Modelltraining integrieren, wodurch der Workflow vereinfacht und die Wiederverwendbarkeit des Codes verbessert wird.
Was ist Pipeline
Pipeline ist ein Werkzeug, das mehrere Datenverarbeitungsschritte und Modelltrainingsschritte nacheinander ausführen kann.
In einer Pipeline ist jeder Schritt ein Tupel, das einen Namen und ein Objekt enthält.
Jedes Objekt ist normalerweise ein Transformer oder ein Estimator, wobei:
- TransformerEin Objekt, das Datentransformationen durchführt, wie z. B. Datenvorverarbeitung (z. B. Normalisierung, Standardisierung, Merkmalsauswahl usw.).
- EstimatorEin Objekt, das zum Trainieren von Modellen verwendet wird, wie z. B. Klassifikatoren oder Regressoren.
PipelineEs macht es einfach, mehrere Schritte in einen wiederverwendbaren Workflow zu integrieren und sorgt für Konsistenz im Datenverarbeitungsprozess, wodurch Fehler durch Code-Duplizierung oder manuelle Bearbeitung vermieden werden.
Warum Pipeline verwenden
- Code vereinfachen: Das Zusammenfassen mehrerer Schritte zu einem Ganzen vereinfacht die Codestruktur und -verwaltung.
- Datenlecks vermeiden: Stellen Sie bei der Datenvorverarbeitung sicher, dass Trainingsset und Testset getrennt verarbeitet werden, um Datenlecks zu vermeiden. Beispielsweise sollten beim Standardisieren Mittelwert und Standardabweichung nicht auf dem Testset berechnet werden.
- Wiederholte Arbeit reduzieren: Durch
Pipelinekönnen Sie die Datenvorverarbeitung und das Modelltraining miteinander verketten, wodurch vermieden wird, den Vorverarbeitungscode für jedes Training wiederholt zu schreiben. - Wiederverwendbarkeit verbessern: Das Kapseln von Datenverarbeitung und Modelltraining in ein
PipelineObjekt ermöglicht die Wiederverwendung über verschiedene Projekte und Datensätze hinweg. - Tuning erleichtern: Durch
Pipelinekönnen Sie während des Tunings direkt Hyperparameteroptimierung, Kreuzvalidierung usw. anwenden, wodurch der gesamte Prozess vereinfacht wird.
Komponenten der Pipeline
Eine Pipeline besteht aus mehreren Schritten, und jeder Schritt ist ein Tupel, das zwei Elemente enthält:
- Schrittname(String-Typ): Dient zur Identifizierung jedes Schritts.
- Transformer oder Estimator: Ein Objekt, das für die Datenverarbeitung oder Modellierung verwendet wird.
Übliche Schritte umfassen:
- Schritte zur Datenvorverarbeitung: Wie Datenbereinigung, Standardisierung, Kodierung usw.
- Schritte zum Modelltraining: Wie Klassifikatoren, Regressoren usw.
Erstellen einer einfachen Pipeline
Angenommen, wir haben einen Datensatz und müssen die Daten standardisieren, bevor wir einen Support Vector Machine (SVM)-Klassifikator trainieren. Wir können die Standardisierung und die Modelltrainingsschritte in einer Pipeline kombinieren.
Beispiel
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris
# Daten laden
data = load_iris()
X, y = data.data, data.target
# Teile den Datensatz in Trainings- und Testsets auf
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Pipeline erstellen
pipeline = Pipeline([
('scaler', StandardScaler()), # Daten standardisieren
('svc', SVC()) # Support Vector Machine-Klassifikator
])
# Modell trainieren
pipeline.fit(X_train, y_train)
# Vorhersagen erstellen
y_pred = pipeline.predict(X_test)
# Modellgenauigkeit ausgeben
print(f"Modellgenauigkeit: {pipeline.score(X_test, y_test)}")
Führen Sie den obigen Code aus, die Ausgabe lautet wie folgt:
Model accuracy: 1.0
Wie die Pipeline funktioniert
Im obigen Beispiel hat die Pipeline zwei Schritte ausgeführt:
- Datenstandardisierung(über
StandardScaler()): Standardisieren Sie die Daten so, dass jedes Merkmal einen Mittelwert von 0 und eine Varianz von 1 hat. - Modelltraining(über
SVC()): Trainieren Sie den Support-Vector-Machine-Klassifikator auf den standardisierten Daten.
PipelineDer Workflow der Pipeline ist: Zuerst die Datenvorverarbeitungsschritte ausführen (wie die Standardisierung), dann die verarbeiteten Daten zum Training an das Modell übergeben. Dieser Prozess kann abgeschlossen werdenpipeline.fit()in einem Schritt,pipeline.predict()und bei der Vorhersage durchlaufen die Daten ebenfalls jeden Schritt in der Pipeline in derselben Reihenfolge.
Vorteile der Pipeline
Code und Workflow vereinfachen
Mithilfe der Pipeline können wir mehrere Schritte zu einem Objekt kombinieren und dadurch den Code für die manuelle Ausführung mehrerer Schritte reduzieren.
Ohne Pipeline muss die Vorverarbeitung mehrmals durchgeführt werden:
Beispiel
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
model = SVC()
model.fit(X_train_scaled, y_train)
y_pred = model.predict(X_test_scaled)
Mit Pipeline wird es in einem Schritt abgeschlossen:
Beispiel
pipeline = Pipeline([
('scaler', StandardScaler()),
('svc', SVC())
])
pipeline.fit(X_train, y_train)
y_pred = pipeline.predict(X_test)
Konsistenz bei der Verarbeitung von Trainings- und Testdaten sicherstellen
Ohne Pipeline kann es vorkommen, dass wir bei manueller Datenverarbeitung und manuellem Training versehentlich unterschiedliche Verarbeitungsmethoden für das Trainingsset und das Testset verwenden, was zu einem Datenleck führt.
Zum Beispiel berechnen wir den Mittelwert und die Varianz für die Standardisierung auf dem Trainingsset, aber wenn auf dem Testset unterschiedliche Mittelwerte und Varianzen berechnet werden, ist die Modellbewertung ungenau. Die Verwendung von Pipeline stellt die Konsistenz dieser Verarbeitungsmethoden sicher.
Den gesamten Prozess automatisieren
Pipeline ermöglicht es uns, mehrere Schritte in einem Objekt zu kapseln und den gesamten Prozess der Datenvorverarbeitung, des Modelltrainings und der Vorhersage zu automatisieren. Dieser automatisierte Workflow reduziert menschliche Fehler und verbessert die Wiederverwendbarkeit des Codes.
Pipeline-Tuning und -Optimierung
Bei Verwendung von Pipeline können wir direkt Hyperparameter-Tuning durchführen.
Durch die Kombination mit GridSearchCV oder RandomizedSearchCV können die Hyperparameter jedes Schritts in der Pipeline optimiert werden.
Tuning von Hyperparametern in Pipeline mit GridSearchCV:
Beispiel
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris
from sklearn.model_selection import GridSearchCV
# Daten laden
data = load_iris()
X, y = data.data, data.target
# Teile den Datensatz in Trainings- und Testsets auf
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Pipeline erstellen
pipeline = Pipeline([
('scaler', StandardScaler()), # Daten standardisieren
('svc', SVC()) # Support Vector Machine-Klassifikator
])
# Modell trainieren
pipeline.fit(X_train, y_train)
# Hyperparameter-Raster definieren
param_grid = {
'svc__C': [0.1, 1, 10], # Den C-Parameter in SVC optimieren
'svc__kernel': ['linear', 'rbf'] # Den Kernel-Parameter optimieren
}
# Ein GridSearchCV-Objekt erstellen
grid_search = GridSearchCV(pipeline, param_grid, cv=5)
# Hyperparameter-Optimierung durchführen
grid_search.fit(X_train, y_train)
# Die besten Parameter und den Score ausgeben
print(f"Beste Parameter: {grid_search.best_params_}")
print(f"Bester Score: {grid_search.best_score_}")
strong>Hinweis:
svc__Cundsvc__kernelJaPipelineMittelSVCDie Hyperparameter der Schritte. Durch Angabe dieser Parameter inGridSearchCVkönnen wir das Modell direkt inPipelinefür die Hyperparameter-Optimierung.cv=5gibt eine 5-fache Kreuzvalidierung an.
Das Ausgabeergebnis ist wie folgt:
Best parameters: {'svc__C': 0.1, 'svc__kernel': 'linear'}
Best score: 0.9583333333333334
Verwendung von Pipeline für die Kreuzvalidierung
Sie können Pipeline mit der Kreuzvalidierung kombinieren, um sicherzustellen, dass der gesamte Modellbewertungsprozess konsistent ist. In der Kreuzvalidierung werden bei jeder Iteration die Trainingsdaten vorverarbeitet und dann wird das Modell zur Validierung trainiert.
Beispiel
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris
from sklearn.model_selection import cross_val_score
# Daten laden
data = load_iris()
X, y = data.data, data.target
# Teile den Datensatz in Trainings- und Testsets auf
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Pipeline erstellen
pipeline = Pipeline([
('scaler', StandardScaler()), # Daten standardisieren
('svc', SVC()) # Support Vector Machine-Klassifikator
])
# Modell trainieren
pipeline.fit(X_train, y_train)
# Führe eine 5-fache Kreuzvalidierung durch
cv_scores = cross_val_score(pipeline, X, y, cv=5)
# Kreuzvalidierungswerte ausgeben
print(f"Kreuzvalidierungswerte: {cv_scores}")
print(f"Durchschnittlicher Kreuzvalidierungswert: {cv_scores.mean()}")
In diesem Beispiel führt cross_val_score automatisch eine Kreuzvalidierung der Daten durch und standardisiert die Daten vor jedem Training.
Das Ausgabeergebnis ist wie folgt:
Cross-validation scores: [0.96666667 0.96666667 0.96666667 0.93333333 1. ] Mean cross-validation score: 0.9666666666666666Andere Erweiterungen