FIX properties of #1805 for BaseSearchCV and RFE

jnothman · jnothman · commit 159bb7b4c63f · 2014-02-06T10:51:38.000+11:00
diff --git a/sklearn/feature_selection/rfe.py b/sklearn/feature_selection/rfe.py
@@ -6,6 +6,7 @@
 
 """Recursive feature elimination for feature ranking"""
 
+from functools import wraps
 import numpy as np
 from ..utils import check_arrays, safe_sqr
 from ..base import BaseEstimator
@@ -36,6 +37,7 @@ class RFE(BaseEstimator, MetaEstimatorMixin, SelectorMixin):
         A supervised learning estimator with a `fit` method that updates a
         `coef_` attribute that holds the fitted parameters. Important features
         must correspond to high absolute values in the `coef_` array.
+        The estimator must also implement a `score` method.
 
         For instance, this is the case for most supervised learning
         algorithms such as Support Vector Classifiers and Generalized
@@ -169,7 +171,13 @@ def fit(self, X, y):
 
         return self
 
-    def predict(self, X):
+    def _delegate_wrapper(self, delegate):
+        def wrapper(X, *args, **kwargs):
+            return delegate(self.transform(X), *args, **kwargs)
+        return wrapper
+
+    @property
+    def predict(self):
         """Reduce X to the selected features and then predict using the
            underlying estimator.
 
@@ -183,9 +191,10 @@ def predict(self, X):
         y : array of shape [n_samples]
             The predicted target values.
         """
-        return self.estimator_.predict(self.transform(X))
+        return self._delegate_wrapper(self.estimator_.predict)
 
-    def score(self, X, y):
+    @property
+    def score(self):
         """Reduce X to the selected features and then return the score of the
            underlying estimator.
 
@@ -197,16 +206,22 @@ def score(self, X, y):
         y : array of shape [n_samples]
             The target values.
         """
-        return self.estimator_.score(self.transform(X), y)
+        return self._delegate_wrapper(self.estimator_.score)
 
     def _get_support_mask(self):
         return self.support_
 
-    def decision_function(self, X):
-        return self.estimator_.decision_function(self.transform(X))
+    @property
+    def decision_function(self):
+        return self._delegate_wrapper(self.estimator_.decision_function)
+
+    @property
+    def predict_proba(self):
+        return self._delegate_wrapper(self.estimator_.predict_proba)
 
-    def predict_proba(self, X):
-        return self.estimator_.predict_proba(self.transform(X))
+    @property
+    def predict_log_proba(self):
+        return self._delegate_wrapper(self.estimator_.predict_log_proba)
 
 
 class RFECV(RFE, MetaEstimatorMixin):
diff --git a/sklearn/grid_search.py b/sklearn/grid_search.py
@@ -325,20 +325,51 @@ def score(self, X, y=None):
 
     @property
     def predict(self):
+        """Call predict on the best estimator"""
         return self.best_estimator_.predict
 
     @property
     def predict_proba(self):
+        """Call predict_proba on the best estimator"""
         return self.best_estimator_.predict_proba
 
+    @property
+    def predict_log_proba(self):
+        """Call predict_log_proba on the best estimator"""
+        return self.best_estimator_.predict_log_proba
+
     @property
     def decision_function(self):
+        """Call decision_function on the best estimator"""
         return self.best_estimator_.decision_function
 
     @property
     def transform(self):
+        """Call transform on the best estimator"""
         return self.best_estimator_.transform
 
+    @property
+    def inverse_transform(self):
+        """Call inverse_transform on the best estimator"""
+        return self.best_estimator_.inverse_transform
+
+    def _check_estimator(self):
+        """Check that estimator can be fitted and score can be computed."""
+        if (not hasattr(self.estimator, 'fit') or
+                not (hasattr(self.estimator, 'predict')
+                     or hasattr(self.estimator, 'score'))):
+            raise TypeError("estimator should a be an estimator implementing"
+                            " 'fit' and 'predict' or 'score' methods,"
+                            " %s (type %s) was passed" %
+                            (self.estimator, type(self.estimator)))
+        if (self.scoring is None and self.loss_func is None and self.score_func
+                is None):
+            if not hasattr(self.estimator, 'score'):
+                raise TypeError(
+                    "If no scoring is specified, the estimator passed "
+                    "should have a 'score' method. The estimator %s "
+                    "does not." % self.estimator)
+
     def _fit(self, X, y, parameter_iterable):
         """Actual fitting,  performing the search over parameters."""
 
diff --git a/sklearn/tests/test_metaestimators.py b/sklearn/tests/test_metaestimators.py
@@ -10,7 +10,7 @@
 from sklearn.utils.testing import assert_true, assert_false
 from sklearn.pipeline import Pipeline
 from sklearn.grid_search import GridSearchCV, RandomizedSearchCV
-from sklearn.feature_selection import RFECV
+from sklearn.feature_selection import RFE, RFECV
 
 
 class DelegatorData(object):
@@ -32,8 +32,10 @@ def __init__(self, name, construct, skip_methods=(),
                   lambda est: RandomizedSearchCV(
                       est, param_distributions={'param': [5]}, cv=2),
                   skip_methods=['score']),
+    DelegatorData('RFE', RFE,
+                  skip_methods=['transform', 'inverse_transform', 'score']),
     DelegatorData('RFECV', RFECV,
-                  skip_methods=['transform', 'inverse_transform']),
+                  skip_methods=['transform', 'inverse_transform', 'score']),
 ]
 
 
@@ -43,7 +45,7 @@ def hides(method):
         @property
         def wrapper(obj):
             if obj.hidden_method == method.__name__:
-                raise AttributeError
+                raise AttributeError('%r is hidden' % obj.hidden_method)
             return functools.partial(method, obj)
         return wrapper
 
@@ -86,6 +88,7 @@ def score(self, X, *args, **kwargs):
 
     methods = [k for k in iterkeys(SubEstimator.__dict__)
                if not k.startswith('_') and not k.startswith('fit')]
+    methods.sort()
 
     for delegator_data in DELEGATING_METAESTIMATORS:
         delegate = SubEstimator()
@@ -98,6 +101,8 @@ def score(self, X, *args, **kwargs):
             assert_true(hasattr(delegator, method),
                         msg="%s does not have method %r when its delegate does"
                             % (delegator_data.name, method))
+            # smoke test delegation
+            getattr(delegator, method)(delegator_data.fit_args[0])
 
         for method in methods:
             if method in delegator_data.skip_methods:
diff --git a/sklearn/tests/test_pipeline.py b/sklearn/tests/test_pipeline.py
