Optional verbosity for Pipeline

samzhang111 · samzhang111 · commit 4e88f3d7b50e · 2015-09-26T15:28:52.000-07:00
Adds named verbosity argument in Pipeline constructor.

After each step, verbose pipelines print to standard output lines like:
&gt; [Pipeline] &lt;step name&gt;, &lt;action&gt; (fit or transform), &lt;duration&gt;
diff --git a/sklearn/pipeline.py b/sklearn/pipeline.py
@@ -16,11 +16,12 @@
 from scipy import sparse
 
 from .base import BaseEstimator, TransformerMixin
-from .externals.joblib import Parallel, delayed
+from .externals.joblib import Parallel, delayed, logger
 from .externals import six
 from .utils import tosequence
 from .utils.metaestimators import if_delegate_has_method
 from .externals.six import iteritems
+import time
 
 __all__ = ['Pipeline', 'FeatureUnion']
 
@@ -72,7 +73,8 @@ class Pipeline(BaseEstimator):
     >>> # and a parameter 'C' of the svm
     >>> anova_svm.set_params(anova__k=10, svc__C=.1).fit(X, y)
     ...                                              # doctest: +ELLIPSIS
-    Pipeline(steps=[...])
+    Pipeline(steps=[...],
+         verbose=False)
     >>> prediction = anova_svm.predict(X)
     >>> anova_svm.score(X, y)                        # doctest: +ELLIPSIS
     0.77...
@@ -86,28 +88,51 @@ class Pipeline(BaseEstimator):
 
     # BaseEstimator interface
 
-    def __init__(self, steps):
+    def __init__(self, steps, verbose=False):
         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)
+        self.verbose = verbose
         transforms = estimators[:-1]
         estimator = estimators[-1]
 
-        for t in transforms:
+        for i, t in enumerate(transforms):
+            if hasattr(t, "fit"):
+                transforms[i].fit = self._wrap_timer(t.fit, names[i], "fit")
+
+            if hasattr(t, "transform"):
+                transforms[i].transform = self._wrap_timer(t.transform,
+                                                           names[i], "transform")
+
             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"):
+        if hasattr(estimator, "fit"):
+            estimator.fit = self._wrap_timer(estimator.fit, names[-1], "fit")
+        else:
             raise TypeError("Last step of chain should implement fit "
                             "'%s' (type %s) doesn't)"
                             % (estimator, type(estimator)))
 
+    def _wrap_timer(self, f, name, action):
+        def timed_f(*args, **kwargs):
+            start_time = time.time()
+            ret = f(*args, **kwargs)
+            elapsed_time = time.time() - start_time
+            time_str = logger.short_format_time(elapsed_time)
+            if self.verbose:
+                print('[Pipeline] %s, %s, %s' % (name, action, time_str))
+
+            return ret
+
+        return timed_f
+
     @property
     def _estimator_type(self):
         return self.steps[-1][1]._estimator_type
@@ -379,7 +404,8 @@ def make_pipeline(*steps):
     >>> make_pipeline(StandardScaler(), GaussianNB())    # doctest: +NORMALIZE_WHITESPACE
     Pipeline(steps=[('standardscaler',
                      StandardScaler(copy=True, with_mean=True, with_std=True)),
-                    ('gaussiannb', GaussianNB())])
+                    ('gaussiannb', GaussianNB())],
+         verbose=False)
 
     Returns
     -------
diff --git a/sklearn/tests/test_pipeline.py b/sklearn/tests/test_pipeline.py
@@ -1,10 +1,12 @@
 """
 Test the pipeline module.
 """
+import sys
 import numpy as np
 from scipy import sparse
 
 from sklearn.externals.six.moves import zip
+from sklearn.externals.six import StringIO
 from sklearn.utils.testing import assert_raises, assert_raises_regex, assert_raise_message
 from sklearn.utils.testing import assert_equal
 from sklearn.utils.testing import assert_false
@@ -449,7 +451,6 @@ def test_feature_union_feature_names():
         assert_true("chars__" in feat or "words__" in feat)
     assert_equal(len(feature_names), 35)
 
-
 def test_classes_property():
     iris = load_iris()
     X = iris.data
@@ -464,10 +465,35 @@ def test_classes_property():
     clf.fit(X, y)
     assert_array_equal(clf.classes_, np.unique(y))
 
-
 def test_X1d_inverse_transform():
     transformer = TransfT()
     pipeline = make_pipeline(transformer)
     X = np.ones(10)
     msg = "1d X will not be reshaped in pipeline.inverse_transform"
     assert_warns_message(FutureWarning, msg, pipeline.inverse_transform, X)
+
+def test_verbosity():
+    iris = load_iris()
+    X = iris.data
+    y = iris.target
+
+    old_stdout = sys.stdout
+    try:
+        out = StringIO()
+        sys.stdout = out
+
+        nonverbose_reg = Pipeline([
+            ('kbest', SelectKBest(k=1)), ('lr', LinearRegression())
+        ], verbose=False)
+        nonverbose_reg.fit(X, y)
+        assert_true("[Pipeline]" not in out.getvalue())
+
+        verbose_reg = Pipeline([
+            ('kbest', SelectKBest(k=1)), ('lr', LinearRegression())
+        ], verbose=True)
+        verbose_reg.fit(X, y)
+        assert_true("[Pipeline] kbest, fit" in out.getvalue())
+        assert_true("[Pipeline] kbest, transform" in out.getvalue())
+        assert_true("[Pipeline] lr, fit" in out.getvalue())
+    finally:
+        sys.stdout = old_stdout
