Scikit-Learn Pipeline Examples

Last updated:
Scikit-Learn Pipeline Examples
Source

Updated for Scikit-learn v0.19 and Keras v2.0.3

WHAT

Pipelines allow you to create a single object that includes all steps from data preprocessing and classification.

WHY

  • Increase reproducibility

  • Make it easier to use cross validation and other types of model selection.

  • Avoid common mistakes such as leaking data from training sets into test sets.

Simplest possible Pipeline

Just a classifier and one preprocessing step (data standardization)

View notebook here

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression

# add your data here
X_train,y_train = make_my_dataset()

# it takes a list of tuples as parameter
pipeline = Pipeline([
    ('scaler',StandardScaler()),
    ('clf', LogisticRegression())
])

# use the pipeline object as you would
# a regular classifier
pipeline.fit(X_train,y_train)

Pipeline for Text Classification/NLP

View notebook here

from sklearn.feature_extraction.text import CountVectorizer,TfidfTransformer
from sklearn.metrics import f1_score
from sklearn.svm import LinearSVC
from sklearn.pipeline import Pipeline

# X_train and X_test are lists of strings, each 
# representing one document
# y_train and y_test are vectors of labels
X_train,X_test,y_train,y_test = make_my_dataset()

# this calculates a vector of term frequencies for 
# each document
vect = CountVectorizer()

# this normalizes each term frequency by the 
# number of documents having that term
tfidf = TfidfTransformer()

# this is a linear SVM classifier
clf = LinearSVC()

pipeline = Pipeline([
    ('vect',vect),
    ('tfidf',tfidf),
    ('clf',clf)
])

# call fit as you would on any classifier
pipeline.fit(X_train,y_train)

# predict test instances
y_preds = pipeline.predict(X_test)

# calculate f1
mean_f1 = f1_score(y_test, y_preds, average='micro')

Pipeline with Cross-Validation (cross_val_score)

View notebook here

Doing cross-validation is one of the main reasons why you should wrap your model steps into a Pipeline.

The recommended method for training a good model is to first cross-validate using a portion of the training set itself to check if

You can cross-validate a whole pipeline using cross_val_score:

from sklearn.feature_extraction.text import CountVectorizer,TfidfTransformer
from sklearn.metrics import f1_score
from sklearn.model_selection import cross_val_score
from sklearn.svm import LinearSVC
from sklearn.pipeline import Pipeline

X_train,X_test,y_train,y_test = make_my_dataset()

pipeline = Pipeline([
    ('vect',CountVectorizer()),
    ('tfidf',TfidfTransformer()),
    ('clf',LinearSVC())
])

# Instead of 'just' fitting the pipeline on the training
# data, do cross-validation too so that you know if it's
# overfitting.
# This returns an array of values, each having the score 
# for an individual run.
# - cv=3 means that we're doing 3-fold cross validation
# - You can select any metric to score your pipeline
scores = cross_val_scores(pipeline,X_train,y_train,cv=3,
    scoring='f1_micro')

# with the information above, you can be more 
# comfortable to train on the whole dataset
pipeline.fit(X_train,y_train)

y_preds = pipeline.predict(y_test)

mean_f1 = f1_score(y_test, y_preds, average='micro')

Pipeline with Cross-Validation (GridSearchCV)

View notebook here

To cross-validate and select the best parameter configuration at the same time, you can use GridSearchCV.

This allows you to easily test out different hyperparameter configurations using for example the KFold strategy to split your model into random parts to find out if it's generalizing well or if it's overfitting.

GridSearchCV allows you do define a ParameterGrid with hyperparameter configuration values to iterate over. All combinations are tested and scored.

In this example, there are 2 x 3 = 6 parameter combinations to test, so the model will be trained and tested on the validation set 6 times.

import numpy as np

from sklearn.feature_extraction.text import CountVectorizer,TfidfTransformer
from sklearn.metrics import f1_score
from sklearn.model_selection import GridSearchCV
from sklearn.svm import LinearSVC
from sklearn.pipeline import Pipeline

X_train,X_test,Y_train,Y_test = make_my_dataset()

pipeline = Pipeline([
    ('vect', CountVectorizer()),
    ('tfidf', TfidfTransformer()),
    ('clf', LinearSVC()),
])

# this is where you define the values for
# GridSearchCV to iterate over
param_grid = {
    'vect__max_df':[0.8,0.9,1.0],
    'clf__C':[0.1,1.0]
}

# do 3-fold cross validation for each of the 6 possible
# combinations of the parameter values above
grid = GridSearchCV(pipeline, cv=3, param_grid=param_grid)
grid.fit(X_train,y_train)

# summarize results
print("Best: %f using %s" % (grid.best_score_, 
    grid.best_params_))
means = grid.cv_results_['mean_test_score']
stds = grid.cv_results_['std_test_score']
params = grid.cv_results_['params']
for mean, stdev, param in zip(means, stds, params):
    print("%f (%f) with: %r" % (mean, stdev, param))

# now train and predict test instances
# using the best configs found in the CV step

Pipeline for Multi-Label Classification with One-vs-Rest Meta Classifier

As above, using text classification as example

A meta-classifier is an object that takes any classifier as argument.

In this example, we have OneVsRestClassifier, which trains the provided classifier one for each different label.

This meta-classifier is very often used in multi-label problems, where it's also known as Binary relevance.

import numpy as np

from sklearn.feature_extraction.text import CountVectorizer,TfidfTransformer
from sklearn.metrics import f1_score
from sklearn.multiclass import OneVsRestClassifier
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import MultiLabelBinarizer
from sklearn.svm import LinearSVC

# X_train and X_test are lists of strings, each 
# representing one document
# Y_train and Y_test are usually lists of lists of labels
X_train,X_test,Y_train,Y_test = make_my_dataset()

all_labels = np.vstack([Y_train,Y_test])

# you need to fit on all labels because you need
# a place for every label
mlb = MultiLabelBinarizer().fit(all_labels)

# there is no data leaking because 'fitting'
# a multilabel binarizer does not really train anything
Y_train_binary = mlb.transform(Y_train)
Y_test_binary = mlb.transform(Y_test)

pipeline = Pipeline([
    ('vect', CountVectorizer()),
    ('tfidf', TfidfTransformer()),
    ('clf', OneVsRestClassifier(LinearSVC(),n_jobs=-1)),
])

# use the transformed Y_train here
pipeline.fit(X_train,Y_train_binary)

# the result is also a binary label matrix
Y_preds_binary = pipeline.predict(X_test)

# calculate f1 on the test set
mean_f1 = f1_score(Y_test_binary, Y_preds_binary, average='micro')

Cross Validation with incompatible Parameter pairs

There are cases when a certain combination of parameters is invalid in some model.

One example is for the LinearSVC classifier, where you can choose among the following options:

  • the penalty parameter may be 'l1' or 'l2'

  • the dual parameter may be True or False.

But the specific combination penalty='l1' and dual=True is invalid, so you need a way to design the Parameter grid so that this particular combination is never used.

You can fix this by defining separate lists in the parameter grid, so that it looks like this:

# add imports here

# add model initialization here

pipeline = Pipeline([
    ('clf', svm.LinearSVC()),
])

parameter_grid = [
    { 
          "clf__penalty": ["l2"],
          "clf__dual":[False,True]
    },
    { 
          "clf__penalty": ["l1"],
          "clf__dual":[False]
    }    
]

grid = GridSearchCV(pipeline, cv=3, param_grid=param_grid)
grid.fit(X_train,y_train)

# add the rest of the code here

Pipeline With a Keras Model

Heads-up: If you're using a GPU, do not use multithreading (i.e. do not change n_jobs parameter)

This example includes using Keras' wrappers for the Scikit-learn API which allows you do define a Keras model and use it within scikit-learn's Pipelines. There are wrappers for classifiers and regressors, depending upon your use case.

import numpy as np

from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import GridSearchCV

from keras.layers import Dense, Dropout,
from keras.models import Model, Sequential
from keras.wrappers.scikit_learn import KerasRegressor

# load your data
X_train,X_test,y_train,y_test = make_my_dataset()

# create a function that returns a model, taking as parameters things you
# want to verify using cross-valdiation and model selection
def create_model(optimizer='adagrad',
                 kernel_initializer='glorot_uniform', 
                 dropout=0.2):
    model = Sequential()
    model.add(Dense(64,activation='relu',kernel_initializer=kernel_initializer))
    model.add(Dropout(dropout))
    model.add(Dense(1,activation='sigmoid',kernel_initializer=kernel_initializer))

    model.compile(loss='binary_crossentropy',optimizer=optimizer, metrics=['accuracy'])

    return model

# wrap the model using the function you created
clf = KerasRegressor(build_fn=create_model,verbose=0)

scaler = StandardScaler()

# create parameter grid, as usual, but note that you can
# vary other model parameters such as 'epochs' (and others 
# such as 'batch_size' too)
param_grid = {
    'clf__optimizer':['rmsprop','adam','adagrad'],
    'clf__epochs':[4,8],
    'clf__dropout':[0.1,0.2],
    'clf__kernel_initializer':['glorot_uniform','normal','uniform']
}

pipeline = Pipeline([
    ('preprocess',scaler),
    ('clf',clf)
])

grid = GridSearchCV(pipeline, cv=3, param_grid=param_grid)
grid.fit(X_train, y_train)

# summarize results
print("Best: %f using %s" % (grid.best_score_, grid.best_params_))
means = grid.cv_results_['mean_test_score']
stds = grid.cv_results_['std_test_score']
params = grid.cv_results_['params']
for mean, stdev, param in zip(means, stds, params):
    print("%f (%f) with: %r" % (mean, stdev, param))

Cross Validation with a Predefined Split

It's very common to use a specific train/test split (e.g. time-based split, where you split the dataset according to each sample's date/time and use values in the past to predict values in the future) for your data, and you must stick to this split when doing cross-validation.

You do a manual Grid Search using a ParameterGrid, and you can manually set the train and validation sets to use:

from sklearn.model_selection import ParameterGrid


# add other imports, load data here

# a simple pipeline with just a classifier
pipeline = Pipeline(['clf': LinearSVC()])

parameters = [
    { 
          "clf__penalty": ["l1","l2"]
    },
]

# start with minus infinity as your
# current best_score
best_score = float("-inf")

for g in ParameterGrid(parameters):
    pipeline.set_params(**g)

    # here you call fit with whatever data you want
    pipeline.fit(X_train,y_train)

    # again, choose the validation data 
    # yourself
    y_pred_train = pipeline.predict(X_train)    
    y_pred_validation = pipeline.predict(X_validation)

    # I've used f1-score as an example, but you can use
    # any metric you want.
    train_score = f1_score(my_y_train,Y_pred_train,
        average='micro')
    val_score = f1_score(y_validation,Y_pred_validation,
        average='micro')

    current_score = val_score

    # show results
    print("training F1: {}".format(train_score))
    print("validation F1: {}".format(val_score))
    print("grid: {}".format(g))
    print("")

    # update the best_score if needed
    if current_score > best_score:
        best_score = current_score
        best_grid = g

References

Dialogue & Discussion