579 lines
21 KiB
Python
579 lines
21 KiB
Python
"""
|
|
The :mod:`sklearn.pipeline` module implements utilities to build a composite
|
|
estimator, as a chain of transforms and estimators.
|
|
"""
|
|
# Author: Edouard Duchesnay
|
|
# Gael Varoquaux
|
|
# Virgile Fritsch
|
|
# Alexandre Gramfort
|
|
# Lars Buitinck
|
|
# Licence: BSD
|
|
|
|
from collections import defaultdict
|
|
from warnings import warn
|
|
|
|
import numpy as np
|
|
from scipy import sparse
|
|
|
|
from .base import BaseEstimator, TransformerMixin
|
|
from .externals.joblib import Parallel, delayed
|
|
from .externals import six
|
|
from .utils import tosequence
|
|
from .utils.metaestimators import if_delegate_has_method
|
|
from .externals.six import iteritems
|
|
|
|
__all__ = ['Pipeline', 'FeatureUnion']
|
|
|
|
|
|
class Pipeline(BaseEstimator):
|
|
"""Pipeline of transforms with a final estimator.
|
|
|
|
Sequentially apply a list of transforms and a final estimator.
|
|
Intermediate steps of the pipeline must be 'transforms', that is, they
|
|
must implement fit and transform methods.
|
|
The final estimator only needs to implement fit.
|
|
|
|
The purpose of the pipeline is to assemble several steps that can be
|
|
cross-validated together while setting different parameters.
|
|
For this, it enables setting parameters of the various steps using their
|
|
names and the parameter name separated by a '__', as in the example below.
|
|
|
|
Read more in the :ref:`User Guide <pipeline>`.
|
|
|
|
Parameters
|
|
----------
|
|
steps : list
|
|
List of (name, transform) tuples (implementing fit/transform) that are
|
|
chained, in the order in which they are chained, with the last object
|
|
an estimator.
|
|
|
|
Attributes
|
|
----------
|
|
named_steps : dict
|
|
Read-only attribute to access any step parameter by user given name.
|
|
Keys are step names and values are steps parameters.
|
|
|
|
Examples
|
|
--------
|
|
>>> from sklearn import svm
|
|
>>> from sklearn.datasets import samples_generator
|
|
>>> from sklearn.feature_selection import SelectKBest
|
|
>>> from sklearn.feature_selection import f_regression
|
|
>>> from sklearn.pipeline import Pipeline
|
|
>>> # generate some data to play with
|
|
>>> X, y = samples_generator.make_classification(
|
|
... n_informative=5, n_redundant=0, random_state=42)
|
|
>>> # ANOVA SVM-C
|
|
>>> anova_filter = SelectKBest(f_regression, k=5)
|
|
>>> clf = svm.SVC(kernel='linear')
|
|
>>> anova_svm = Pipeline([('anova', anova_filter), ('svc', clf)])
|
|
>>> # You can set the parameters using the names issued
|
|
>>> # For instance, fit using a k of 10 in the SelectKBest
|
|
>>> # and a parameter 'C' of the svm
|
|
>>> anova_svm.set_params(anova__k=10, svc__C=.1).fit(X, y)
|
|
... # doctest: +ELLIPSIS
|
|
Pipeline(steps=[...])
|
|
>>> prediction = anova_svm.predict(X)
|
|
>>> anova_svm.score(X, y) # doctest: +ELLIPSIS
|
|
0.77...
|
|
>>> # getting the selected features chosen by anova_filter
|
|
>>> anova_svm.named_steps['anova'].get_support()
|
|
... # doctest: +NORMALIZE_WHITESPACE
|
|
array([ True, True, True, False, False, True, False, True, True, True,
|
|
False, False, True, False, True, False, False, False, False,
|
|
True], dtype=bool)
|
|
"""
|
|
|
|
# BaseEstimator interface
|
|
|
|
def __init__(self, steps):
|
|
names, estimators = zip(*steps)
|
|
if len(dict(steps)) != len(steps):
|
|
raise ValueError("Provided step names are not unique: %s"
|
|
% (names,))
|
|
|
|
# shallow copy of steps
|
|
self.steps = tosequence(steps)
|
|
transforms = estimators[:-1]
|
|
estimator = estimators[-1]
|
|
|
|
for t in transforms:
|
|
if (not (hasattr(t, "fit") or hasattr(t, "fit_transform")) or not
|
|
hasattr(t, "transform")):
|
|
raise TypeError("All intermediate steps of the chain should "
|
|
"be transforms and implement fit and transform"
|
|
" '%s' (type %s) doesn't)" % (t, type(t)))
|
|
|
|
if not hasattr(estimator, "fit"):
|
|
raise TypeError("Last step of chain should implement fit "
|
|
"'%s' (type %s) doesn't)"
|
|
% (estimator, type(estimator)))
|
|
|
|
@property
|
|
def _estimator_type(self):
|
|
return self.steps[-1][1]._estimator_type
|
|
|
|
def get_params(self, deep=True):
|
|
if not deep:
|
|
return super(Pipeline, self).get_params(deep=False)
|
|
else:
|
|
out = self.named_steps
|
|
for name, step in six.iteritems(self.named_steps):
|
|
for key, value in six.iteritems(step.get_params(deep=True)):
|
|
out['%s__%s' % (name, key)] = value
|
|
|
|
out.update(super(Pipeline, self).get_params(deep=False))
|
|
return out
|
|
|
|
@property
|
|
def named_steps(self):
|
|
return dict(self.steps)
|
|
|
|
@property
|
|
def _final_estimator(self):
|
|
return self.steps[-1][1]
|
|
|
|
# Estimator interface
|
|
|
|
def _pre_transform(self, X, y=None, **fit_params):
|
|
fit_params_steps = dict((step, {}) for step, _ in self.steps)
|
|
for pname, pval in six.iteritems(fit_params):
|
|
step, param = pname.split('__', 1)
|
|
fit_params_steps[step][param] = pval
|
|
Xt = X
|
|
for name, transform in self.steps[:-1]:
|
|
if hasattr(transform, "fit_transform"):
|
|
Xt = transform.fit_transform(Xt, y, **fit_params_steps[name])
|
|
else:
|
|
Xt = transform.fit(Xt, y, **fit_params_steps[name]) \
|
|
.transform(Xt)
|
|
return Xt, fit_params_steps[self.steps[-1][0]]
|
|
|
|
def fit(self, X, y=None, **fit_params):
|
|
"""Fit all the transforms one after the other and transform the
|
|
data, then fit the transformed data using the final estimator.
|
|
|
|
Parameters
|
|
----------
|
|
X : iterable
|
|
Training data. Must fulfill input requirements of first step of the
|
|
pipeline.
|
|
y : iterable, default=None
|
|
Training targets. Must fulfill label requirements for all steps of
|
|
the pipeline.
|
|
"""
|
|
Xt, fit_params = self._pre_transform(X, y, **fit_params)
|
|
self.steps[-1][-1].fit(Xt, y, **fit_params)
|
|
return self
|
|
|
|
def fit_transform(self, X, y=None, **fit_params):
|
|
"""Fit all the transforms one after the other and transform the
|
|
data, then use fit_transform on transformed data using the final
|
|
estimator.
|
|
|
|
Parameters
|
|
----------
|
|
X : iterable
|
|
Training data. Must fulfill input requirements of first step of the
|
|
pipeline.
|
|
|
|
y : iterable, default=None
|
|
Training targets. Must fulfill label requirements for all steps of
|
|
the pipeline.
|
|
"""
|
|
Xt, fit_params = self._pre_transform(X, y, **fit_params)
|
|
if hasattr(self.steps[-1][-1], 'fit_transform'):
|
|
return self.steps[-1][-1].fit_transform(Xt, y, **fit_params)
|
|
else:
|
|
return self.steps[-1][-1].fit(Xt, y, **fit_params).transform(Xt)
|
|
|
|
@if_delegate_has_method(delegate='_final_estimator')
|
|
def predict(self, X):
|
|
"""Applies transforms to the data, and the predict method of the
|
|
final estimator. Valid only if the final estimator implements
|
|
predict.
|
|
|
|
Parameters
|
|
----------
|
|
X : iterable
|
|
Data to predict on. Must fulfill input requirements of first step
|
|
of the pipeline.
|
|
"""
|
|
Xt = X
|
|
for name, transform in self.steps[:-1]:
|
|
Xt = transform.transform(Xt)
|
|
return self.steps[-1][-1].predict(Xt)
|
|
|
|
@if_delegate_has_method(delegate='_final_estimator')
|
|
def fit_predict(self, X, y=None, **fit_params):
|
|
"""Applies fit_predict of last step in pipeline after transforms.
|
|
|
|
Applies fit_transforms of a pipeline to the data, followed by the
|
|
fit_predict method of the final estimator in the pipeline. Valid
|
|
only if the final estimator implements fit_predict.
|
|
|
|
Parameters
|
|
----------
|
|
X : iterable
|
|
Training data. Must fulfill input requirements of first step of
|
|
the pipeline.
|
|
y : iterable, default=None
|
|
Training targets. Must fulfill label requirements for all steps
|
|
of the pipeline.
|
|
"""
|
|
Xt, fit_params = self._pre_transform(X, y, **fit_params)
|
|
return self.steps[-1][-1].fit_predict(Xt, y, **fit_params)
|
|
|
|
@if_delegate_has_method(delegate='_final_estimator')
|
|
def predict_proba(self, X):
|
|
"""Applies transforms to the data, and the predict_proba method of the
|
|
final estimator. Valid only if the final estimator implements
|
|
predict_proba.
|
|
|
|
Parameters
|
|
----------
|
|
X : iterable
|
|
Data to predict on. Must fulfill input requirements of first step
|
|
of the pipeline.
|
|
"""
|
|
Xt = X
|
|
for name, transform in self.steps[:-1]:
|
|
Xt = transform.transform(Xt)
|
|
return self.steps[-1][-1].predict_proba(Xt)
|
|
|
|
@if_delegate_has_method(delegate='_final_estimator')
|
|
def decision_function(self, X):
|
|
"""Applies transforms to the data, and the decision_function method of
|
|
the final estimator. Valid only if the final estimator implements
|
|
decision_function.
|
|
|
|
Parameters
|
|
----------
|
|
X : iterable
|
|
Data to predict on. Must fulfill input requirements of first step
|
|
of the pipeline.
|
|
"""
|
|
Xt = X
|
|
for name, transform in self.steps[:-1]:
|
|
Xt = transform.transform(Xt)
|
|
return self.steps[-1][-1].decision_function(Xt)
|
|
|
|
@if_delegate_has_method(delegate='_final_estimator')
|
|
def predict_log_proba(self, X):
|
|
"""Applies transforms to the data, and the predict_log_proba method of
|
|
the final estimator. Valid only if the final estimator implements
|
|
predict_log_proba.
|
|
|
|
Parameters
|
|
----------
|
|
X : iterable
|
|
Data to predict on. Must fulfill input requirements of first step
|
|
of the pipeline.
|
|
"""
|
|
Xt = X
|
|
for name, transform in self.steps[:-1]:
|
|
Xt = transform.transform(Xt)
|
|
return self.steps[-1][-1].predict_log_proba(Xt)
|
|
|
|
@if_delegate_has_method(delegate='_final_estimator')
|
|
def transform(self, X):
|
|
"""Applies transforms to the data, and the transform method of the
|
|
final estimator. Valid only if the final estimator implements
|
|
transform.
|
|
|
|
Parameters
|
|
----------
|
|
X : iterable
|
|
Data to predict on. Must fulfill input requirements of first step
|
|
of the pipeline.
|
|
"""
|
|
Xt = X
|
|
for name, transform in self.steps:
|
|
Xt = transform.transform(Xt)
|
|
return Xt
|
|
|
|
@if_delegate_has_method(delegate='_final_estimator')
|
|
def inverse_transform(self, X):
|
|
"""Applies inverse transform to the data.
|
|
Starts with the last step of the pipeline and applies
|
|
``inverse_transform`` in inverse order of the pipeline steps.
|
|
Valid only if all steps of the pipeline implement inverse_transform.
|
|
|
|
Parameters
|
|
----------
|
|
X : iterable
|
|
Data to inverse transform. Must fulfill output requirements of the
|
|
last step of the pipeline.
|
|
"""
|
|
if X.ndim == 1:
|
|
warn("From version 0.19, a 1d X will not be reshaped in"
|
|
" pipeline.inverse_transform any more.", FutureWarning)
|
|
X = X[None, :]
|
|
Xt = X
|
|
for name, step in self.steps[::-1]:
|
|
Xt = step.inverse_transform(Xt)
|
|
return Xt
|
|
|
|
@if_delegate_has_method(delegate='_final_estimator')
|
|
def score(self, X, y=None):
|
|
"""Applies transforms to the data, and the score method of the
|
|
final estimator. Valid only if the final estimator implements
|
|
score.
|
|
|
|
Parameters
|
|
----------
|
|
X : iterable
|
|
Data to score. Must fulfill input requirements of first step of the
|
|
pipeline.
|
|
|
|
y : iterable, default=None
|
|
Targets used for scoring. Must fulfill label requirements for all
|
|
steps of the pipeline.
|
|
"""
|
|
Xt = X
|
|
for name, transform in self.steps[:-1]:
|
|
Xt = transform.transform(Xt)
|
|
return self.steps[-1][-1].score(Xt, y)
|
|
|
|
@property
|
|
def classes_(self):
|
|
return self.steps[-1][-1].classes_
|
|
|
|
@property
|
|
def _pairwise(self):
|
|
# check if first estimator expects pairwise input
|
|
return getattr(self.steps[0][1], '_pairwise', False)
|
|
|
|
|
|
def _name_estimators(estimators):
|
|
"""Generate names for estimators."""
|
|
|
|
names = [type(estimator).__name__.lower() for estimator in estimators]
|
|
namecount = defaultdict(int)
|
|
for est, name in zip(estimators, names):
|
|
namecount[name] += 1
|
|
|
|
for k, v in list(six.iteritems(namecount)):
|
|
if v == 1:
|
|
del namecount[k]
|
|
|
|
for i in reversed(range(len(estimators))):
|
|
name = names[i]
|
|
if name in namecount:
|
|
names[i] += "-%d" % namecount[name]
|
|
namecount[name] -= 1
|
|
|
|
return list(zip(names, estimators))
|
|
|
|
|
|
def make_pipeline(*steps):
|
|
"""Construct a Pipeline from the given estimators.
|
|
|
|
This is a shorthand for the Pipeline constructor; it does not require, and
|
|
does not permit, naming the estimators. Instead, their names will be set
|
|
to the lowercase of their types automatically.
|
|
|
|
Examples
|
|
--------
|
|
>>> from sklearn.naive_bayes import GaussianNB
|
|
>>> from sklearn.preprocessing import StandardScaler
|
|
>>> make_pipeline(StandardScaler(), GaussianNB(priors=None)) # doctest: +NORMALIZE_WHITESPACE
|
|
Pipeline(steps=[('standardscaler',
|
|
StandardScaler(copy=True, with_mean=True, with_std=True)),
|
|
('gaussiannb', GaussianNB(priors=None))])
|
|
|
|
Returns
|
|
-------
|
|
p : Pipeline
|
|
"""
|
|
return Pipeline(_name_estimators(steps))
|
|
|
|
|
|
def _fit_one_transformer(transformer, X, y):
|
|
return transformer.fit(X, y)
|
|
|
|
|
|
def _transform_one(transformer, name, X, transformer_weights):
|
|
if transformer_weights is not None and name in transformer_weights:
|
|
# if we have a weight for this transformer, multiply output
|
|
return transformer.transform(X) * transformer_weights[name]
|
|
return transformer.transform(X)
|
|
|
|
|
|
def _fit_transform_one(transformer, name, X, y, transformer_weights,
|
|
**fit_params):
|
|
if transformer_weights is not None and name in transformer_weights:
|
|
# if we have a weight for this transformer, multiply output
|
|
if hasattr(transformer, 'fit_transform'):
|
|
X_transformed = transformer.fit_transform(X, y, **fit_params)
|
|
return X_transformed * transformer_weights[name], transformer
|
|
else:
|
|
X_transformed = transformer.fit(X, y, **fit_params).transform(X)
|
|
return X_transformed * transformer_weights[name], transformer
|
|
if hasattr(transformer, 'fit_transform'):
|
|
X_transformed = transformer.fit_transform(X, y, **fit_params)
|
|
return X_transformed, transformer
|
|
else:
|
|
X_transformed = transformer.fit(X, y, **fit_params).transform(X)
|
|
return X_transformed, transformer
|
|
|
|
|
|
class FeatureUnion(BaseEstimator, TransformerMixin):
|
|
"""Concatenates results of multiple transformer objects.
|
|
|
|
This estimator applies a list of transformer objects in parallel to the
|
|
input data, then concatenates the results. This is useful to combine
|
|
several feature extraction mechanisms into a single transformer.
|
|
|
|
Read more in the :ref:`User Guide <feature_union>`.
|
|
|
|
Parameters
|
|
----------
|
|
transformer_list: list of (string, transformer) tuples
|
|
List of transformer objects to be applied to the data. The first
|
|
half of each tuple is the name of the transformer.
|
|
|
|
n_jobs: int, optional
|
|
Number of jobs to run in parallel (default 1).
|
|
|
|
transformer_weights: dict, optional
|
|
Multiplicative weights for features per transformer.
|
|
Keys are transformer names, values the weights.
|
|
|
|
"""
|
|
def __init__(self, transformer_list, n_jobs=1, transformer_weights=None):
|
|
self.transformer_list = transformer_list
|
|
self.n_jobs = n_jobs
|
|
self.transformer_weights = transformer_weights
|
|
|
|
def get_feature_names(self):
|
|
"""Get feature names from all transformers.
|
|
|
|
Returns
|
|
-------
|
|
feature_names : list of strings
|
|
Names of the features produced by transform.
|
|
"""
|
|
feature_names = []
|
|
for name, trans in self.transformer_list:
|
|
if not hasattr(trans, 'get_feature_names'):
|
|
raise AttributeError("Transformer %s does not provide"
|
|
" get_feature_names." % str(name))
|
|
feature_names.extend([name + "__" + f for f in
|
|
trans.get_feature_names()])
|
|
return feature_names
|
|
|
|
def fit(self, X, y=None):
|
|
"""Fit all transformers using X.
|
|
|
|
Parameters
|
|
----------
|
|
X : array-like or sparse matrix, shape (n_samples, n_features)
|
|
Input data, used to fit transformers.
|
|
"""
|
|
transformers = Parallel(n_jobs=self.n_jobs)(
|
|
delayed(_fit_one_transformer)(trans, X, y)
|
|
for name, trans in self.transformer_list)
|
|
self._update_transformer_list(transformers)
|
|
return self
|
|
|
|
def fit_transform(self, X, y=None, **fit_params):
|
|
"""Fit all transformers using X, transform the data and concatenate
|
|
results.
|
|
|
|
Parameters
|
|
----------
|
|
X : array-like or sparse matrix, shape (n_samples, n_features)
|
|
Input data to be transformed.
|
|
|
|
Returns
|
|
-------
|
|
X_t : array-like or sparse matrix, shape (n_samples, sum_n_components)
|
|
hstack of results of transformers. sum_n_components is the
|
|
sum of n_components (output dimension) over transformers.
|
|
"""
|
|
result = Parallel(n_jobs=self.n_jobs)(
|
|
delayed(_fit_transform_one)(trans, name, X, y,
|
|
self.transformer_weights, **fit_params)
|
|
for name, trans in self.transformer_list)
|
|
|
|
Xs, transformers = zip(*result)
|
|
self._update_transformer_list(transformers)
|
|
if any(sparse.issparse(f) for f in Xs):
|
|
Xs = sparse.hstack(Xs).tocsr()
|
|
else:
|
|
Xs = np.hstack(Xs)
|
|
return Xs
|
|
|
|
def transform(self, X):
|
|
"""Transform X separately by each transformer, concatenate results.
|
|
|
|
Parameters
|
|
----------
|
|
X : array-like or sparse matrix, shape (n_samples, n_features)
|
|
Input data to be transformed.
|
|
|
|
Returns
|
|
-------
|
|
X_t : array-like or sparse matrix, shape (n_samples, sum_n_components)
|
|
hstack of results of transformers. sum_n_components is the
|
|
sum of n_components (output dimension) over transformers.
|
|
"""
|
|
Xs = Parallel(n_jobs=self.n_jobs)(
|
|
delayed(_transform_one)(trans, name, X, self.transformer_weights)
|
|
for name, trans in self.transformer_list)
|
|
if any(sparse.issparse(f) for f in Xs):
|
|
Xs = sparse.hstack(Xs).tocsr()
|
|
else:
|
|
Xs = np.hstack(Xs)
|
|
return Xs
|
|
|
|
def get_params(self, deep=True):
|
|
if not deep:
|
|
return super(FeatureUnion, self).get_params(deep=False)
|
|
else:
|
|
out = dict(self.transformer_list)
|
|
for name, trans in self.transformer_list:
|
|
for key, value in iteritems(trans.get_params(deep=True)):
|
|
out['%s__%s' % (name, key)] = value
|
|
out.update(super(FeatureUnion, self).get_params(deep=False))
|
|
return out
|
|
|
|
def _update_transformer_list(self, transformers):
|
|
self.transformer_list[:] = [
|
|
(name, new)
|
|
for ((name, old), new) in zip(self.transformer_list, transformers)
|
|
]
|
|
|
|
|
|
# XXX it would be nice to have a keyword-only n_jobs argument to this function,
|
|
# but that's not allowed in Python 2.x.
|
|
def make_union(*transformers):
|
|
"""Construct a FeatureUnion from the given transformers.
|
|
|
|
This is a shorthand for the FeatureUnion constructor; it does not require,
|
|
and does not permit, naming the transformers. Instead, they will be given
|
|
names automatically based on their types. It also does not allow weighting.
|
|
|
|
Examples
|
|
--------
|
|
>>> from sklearn.decomposition import PCA, TruncatedSVD
|
|
>>> make_union(PCA(), TruncatedSVD()) # doctest: +NORMALIZE_WHITESPACE
|
|
FeatureUnion(n_jobs=1,
|
|
transformer_list=[('pca',
|
|
PCA(copy=True, iterated_power=4,
|
|
n_components=None, random_state=None,
|
|
svd_solver='auto', tol=0.0, whiten=False)),
|
|
('truncatedsvd',
|
|
TruncatedSVD(algorithm='randomized',
|
|
n_components=2, n_iter=5,
|
|
random_state=None, tol=0.0))],
|
|
transformer_weights=None)
|
|
|
|
|
|
Returns
|
|
-------
|
|
f : FeatureUnion
|
|
"""
|
|
return FeatureUnion(_name_estimators(transformers))
|