Scikit-learn Pipeline：机器学习工作流程自动化终极指南

            
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
from sklearn.metrics import accuracy_score

# Generate some sample data
X, y = np.random.rand(100, 5) * 10, (np.random.rand(100) > 0.5).astype(int)

# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

            

              
                Copy
              
            
          

            
# Create the pipeline steps
steps = [
    ('scaler', StandardScaler()),
    ('classifier', LogisticRegression())
]

# Create the Pipeline object
pipe = Pipeline(steps)

# Now, you can treat the 'pipe' object as if it were a regular model.
# Let's train it on our training data.
pipe.fit(X_train, y_train)

# Make predictions on the test data
y_pred = pipe.predict(X_test)

# Evaluate the model
accuracy = accuracy_score(y_test, y_pred)
print(f"Pipeline Accuracy: {accuracy:.4f}")

            

              
                Copy
              
            
          

            
import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
from sklearn.impute import SimpleImputer

# Create a sample DataFrame
data = {
    'age': [25, 30, 45, 35, 50, np.nan, 22],
    'salary': [50000, 60000, 120000, 80000, 150000, 75000, 45000],
    'country': ['USA', 'Canada', 'USA', 'UK', 'Canada', 'USA', 'UK'],
    'purchased': [0, 1, 1, 0, 1, 1, 0]
}
df = pd.DataFrame(data)

X = df.drop('purchased', axis=1)
y = df['purchased']

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

# Identify numerical and categorical columns
numerical_features = ['age', 'salary']
categorical_features = ['country']

            

              
                Copy
              
            
          

            
# Create a pipeline for numerical features
numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler())
])

# Create a pipeline for categorical features
categorical_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('onehot', OneHotEncoder(handle_unknown='ignore'))
])

            

              
                Copy
              
            
          

            
# Create the preprocessor with ColumnTransformer
preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, numerical_features),
        ('cat', categorical_transformer, categorical_features)
    ])

            

              
                Copy
              
            
          

            
from sklearn.ensemble import RandomForestClassifier

# Create the full pipeline
full_pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('classifier', RandomForestClassifier(random_state=42))
])

# Train and evaluate the full pipeline
full_pipeline.fit(X_train, y_train)

print("Model score on test data:", full_pipeline.score(X_test, y_test))

# You can now make predictions on new raw data
new_data = pd.DataFrame({
    'age': [40, 28],
    'salary': [90000, 55000],
    'country': ['USA', 'Germany'] # 'Germany' is an unknown category
})

predictions = full_pipeline.predict(new_data)
print("Predictions for new data:", predictions)

            

              
                Copy
              
            
          

            
from sklearn.base import BaseEstimator, TransformerMixin

# Define column indices (can also pass names)
age_ix, salary_ix = 0, 1

class FeatureRatioAdder(BaseEstimator, TransformerMixin):
    def __init__(self):
        pass # No parameters to set
    def fit(self, X, y=None):
        return self # Nothing to learn during fit, so just return self
    def transform(self, X):
        salary_age_ratio = X[:, salary_ix] / X[:, age_ix]
        return np.c_[X, salary_age_ratio] # Concatenate original X with new feature

            

              
                Copy
              
            
          

            
numeric_transformer_with_custom = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),
    ('ratio_adder', FeatureRatioAdder()), # Our custom transformer
    ('scaler', StandardScaler())
])

            

              
                Copy
              
            
          

            
from sklearn.model_selection import GridSearchCV

# We use the 'full_pipeline' from the ColumnTransformer example

# Define the parameter grid
param_grid = {
    'preprocessor__num__imputer__strategy': ['mean', 'median'],
    'classifier__n_estimators': [50, 100, 200],
    'classifier__max_depth': [None, 10, 20],
    'classifier__min_samples_leaf': [1, 2, 4]
}

# Create the GridSearchCV object
grid_search = GridSearchCV(full_pipeline, param_grid, cv=5, verbose=1, n_jobs=-1)

# Fit it to the data
grid_search.fit(X_train, y_train)

# Print the best parameters and score
print("Best parameters found: ", grid_search.best_params_)
print("Best cross-validation score: ", grid_search.best_score_)

# The best estimator is already refitted on the whole training data
best_model = grid_search.best_estimator_
print("Test set score with best model: ", best_model.score(X_test, y_test))

            

              
                Copy
              
            
          

            
from sklearn import set_config

# Set display to 'diagram' to get the visual representation
set_config(display='diagram')

# Now, simply displaying the pipeline object in a Jupyter Notebook or similar environment will render it
full_pipeline

            

              
                Copy
              
            
          

            
# Access the final classifier of the fitted pipeline
final_classifier = full_pipeline.named_steps['classifier']
print("Feature importances:", final_classifier.feature_importances_)

# Access the OneHotEncoder to see the learned categories
onehot_encoder = full_pipeline.named_steps['preprocessor'].named_transformers_['cat'].named_steps['onehot']
print("Categorical features learned:", onehot_encoder.categories_)

            

              
                Copy