[Sklearn] Pipeline

1. What is Pipeline?

Pipelines are a simple way to keep our data preprocessing and modeling code organized. Specifically, a pipeline bundles preprocessing and modeling steps so we can use the whole bundle as if it were a single step. Many data scientists hack together models without pipellines, but pipelines have some important benefits.

 

• Clearner code : Accounting for data at each step of preprocessing can get messy. With a pipline, we won't need to manually keep track of our training and validation data at each top.
• Fewer Bugs : There are fewer opportunities to misapply a step or forget a preprocessing step.
• Easier to Productionize : It can be surprisingly hard to transition a model from a prototype to something deployable at scale. We won't go into the many related concerns here, but piplines can help.
• More Options for Model Validation

 

2. How to use Pipeline?

Step 1 : Prepare our dataset

# Progress of Machine Learning 
# Preprocessing 
import pandas as pd
from sklearn.model_selection import train_test_split

# Read the data
data = pd.read_csv('../../KAGGLE/Kaggle_House_Price/train.csv')

# Separate target from predictors
y = data.SalePrice
X = data.drop(['SalePrice'], axis = 1)

# Divide data into training and validation datasets
X_train_full, X_valid_full, y_train, y_valid = train_test_split(X, y, train_size = 0.8, test_size = 0.2, random_state = 0)


# "Cardinality" means the number of unique values in a column
# Select categorical columns with relatively low cardinality (convenient but arbitrary)
categorical_cols = [cname for cname in X_train_full.columns if X_train_full[cname].nunique() < 10 and X_train_full[cname].dtype == 'object']

# Select numerical columns
numerical_cols = [cname for cname in X_train_full.columns if X_train_full[cname].dtype in ['int64', 'float64']]

# Keep selected columns only
my_cols = categorical_cols + numerical_cols 
X_train = X_train_full[my_cols].copy()
X_valid = X_valid_full[my_cols].copy()

 

Step 2 : Define preprocessing steps

Similar to how a pipeline bundles together preprocessing and modeling steps, we use the ColumnTransformer class to bundle together different preprocessing steps.

 

# Import libraries
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder

# Preprocessing for numerical data
numerical_transformer = SimpleImputer(strategy = 'constant')

# Preprocessing for categorical data
categorical_transformer = Pipeline(steps = [('imputer', SimpleImputer(strategy = 'most_frequent')),
                                            ('onehot', OneHotEncoder(handle_unknown = 'ignore'))])

# Bundle preprocessing for numercal and categorical data
preprocessor = ColumnTransformer(
    transformers = [('num', numerical_transformer, numerical_cols),
                    ('cat', categorical_transformer, categorical_cols)])

 

Step 3 : Define the model

from sklearn.ensemble import RandomForestRegressor
model = RandomForestRegressor(n_estimators = 100, random_state = 0)

 

Step 4 : Create and evaluate the pipeline

There are few important things to notice :

• With the pipeline, we preprocess the training data and fit the model in a single line of code.
• With the pipeline, we supply the unprocessed features in X_valid to the predict command, and the pipeline automatically preprocess the features before generating predictions.

 

from sklearn.metrics import mean_absolute_error

# Bundle preprocessing and modeling code in a pipeline
my_pipeline = Pipeline(steps = [('preprocessor', preprocessor),
                                ('model', model)])

# Preprocessing of training data, fit model
my_pipeline.fit(X_train, y_train)

# Preprocessing of validation data, get predcitions
preds = my_pipeline.predict(X_valid)

# Evaluate the model
score = mean_absolute_error(y_valid, preds)
print("MAE : ", score)

 

 

Source from : https://www.kaggle.com/learn