[MRG+ ½] Fixing #7155 in stochastic_gradient.py

sklearn/grid_search.py

@@ -425,7 +425,7 @@ def score(self, X, y=None):
                           ChangedBehaviorWarning)
         return self.scorer_(self.best_estimator_, X, y)
 
-    @if_delegate_has_method(delegate='estimator')
+    @if_delegate_has_method(delegate=('best_estimator_', 'estimator'))
     def predict(self, X):
         """Call predict on the estimator with the best found parameters.
 
@@ -441,7 +441,7 @@ def predict(self, X):
         """
         return self.best_estimator_.predict(X)
 
-    @if_delegate_has_method(delegate='estimator')
+    @if_delegate_has_method(delegate=('best_estimator_', 'estimator'))
     def predict_proba(self, X):
         """Call predict_proba on the estimator with the best found parameters.
 
@@ -457,7 +457,7 @@ def predict_proba(self, X):
         """
         return self.best_estimator_.predict_proba(X)
 
-    @if_delegate_has_method(delegate='estimator')
+    @if_delegate_has_method(delegate=('best_estimator_', 'estimator'))
     def predict_log_proba(self, X):
         """Call predict_log_proba on the estimator with the best found parameters.
 
@@ -473,7 +473,7 @@ def predict_log_proba(self, X):
         """
         return self.best_estimator_.predict_log_proba(X)
 
-    @if_delegate_has_method(delegate='estimator')
+    @if_delegate_has_method(delegate=('best_estimator_', 'estimator'))
     def decision_function(self, X):
         """Call decision_function on the estimator with the best found parameters.
 
@@ -489,7 +489,7 @@ def decision_function(self, X):
         """
         return self.best_estimator_.decision_function(X)
 
-    @if_delegate_has_method(delegate='estimator')
+    @if_delegate_has_method(delegate=('best_estimator_', 'estimator'))
     def transform(self, X):
         """Call transform on the estimator with the best found parameters.
 
@@ -505,7 +505,7 @@ def transform(self, X):
         """
         return self.best_estimator_.transform(X)
 
-    @if_delegate_has_method(delegate='estimator')
+    @if_delegate_has_method(delegate=('best_estimator_', 'estimator'))
     def inverse_transform(self, Xt):
         """Call inverse_transform on the estimator with the best found parameters.
 

sklearn/utils/metaestimators.py

@@ -14,16 +14,22 @@ class _IffHasAttrDescriptor(object):
     """Implements a conditional property using the descriptor protocol.
 
     Using this class to create a decorator will raise an ``AttributeError``
-    if the ``attribute_name`` is not present on the base object.
+    if none of the delegates (specified in ``delegate_names``) is an attribute
+    of the base object or none of the delegates has an attribute
+    ``attribute_name``.
 
-    This allows ducktyping of the decorated method based on ``attribute_name``.
+    This allows ducktyping of the decorated method based on
+    ``delegate.attribute_name`` where ``delegate`` is the first item in
+    ``delegate_names`` that is an attribute of the base object.
 
     See https://docs.python.org/3/howto/descriptor.html for an explanation of
     descriptors.
     """
-    def __init__(self, fn, attribute_name):
+    def __init__(self, fn, delegate_names, attribute_name):
         self.fn = fn
-        self.get_attribute = attrgetter(attribute_name)
+        self.delegate_names = delegate_names
+        self.attribute_name = attribute_name
+
         # update the docstring of the descriptor
         update_wrapper(self, fn)
 
@@ -32,7 +38,17 @@ def __get__(self, obj, type=None):
         if obj is not None:
             # delegate only on instances, not the classes.
             # this is to allow access to the docstrings.
-            self.get_attribute(obj)
+            for delegate_name in self.delegate_names:
+                try:
+                    delegate = attrgetter(delegate_name)(obj)
+                except AttributeError:
+                    continue
+                else:
+                    getattr(delegate, self.attribute_name)
+                    break
+            else:
+                attrgetter(self.delegate_names[-1])(obj)
+
         # lambda, but not partial, allows help() to work with update_wrapper
         out = lambda *args, **kwargs: self.fn(obj, *args, **kwargs)
         # update the docstring of the returned function
@@ -46,27 +62,18 @@ def if_delegate_has_method(delegate):
     This enables ducktyping by hasattr returning True according to the
     sub-estimator.
 
-    >>> from sklearn.utils.metaestimators import if_delegate_has_method
-    >>>
-    >>>
-    >>> class MetaEst(object):
-    ...     def __init__(self, sub_est):
-    ...         self.sub_est = sub_est
-    ...
-    ...     @if_delegate_has_method(delegate='sub_est')
-    ...     def predict(self, X):
-    ...         return self.sub_est.predict(X)
-    ...
-    >>> class HasPredict(object):
-    ...     def predict(self, X):
-    ...         return X.sum(axis=1)
-    ...
-    >>> class HasNoPredict(object):
-    ...     pass
-    ...
-    >>> hasattr(MetaEst(HasPredict()), 'predict')
-    True
-    >>> hasattr(MetaEst(HasNoPredict()), 'predict')
-    False
+    Parameters
+    ----------
+    delegate : string, list of strings or tuple of strings
+        Name of the sub-estimator that can be accessed as an attribute of the
+        base object. If a list or a tuple of names are provided, the first
+        sub-estimator that is an attribute of the base object  will be used.
+
     """
-    return lambda fn: _IffHasAttrDescriptor(fn, '%s.%s' % (delegate, fn.__name__))
+    if isinstance(delegate, list):
+        delegate = tuple(delegate)
+    if not isinstance(delegate, tuple):
+        delegate = (delegate,)
+
+    return lambda fn: _IffHasAttrDescriptor(fn, delegate,
+                                            attribute_name=fn.__name__)

sklearn/utils/tests/test_metaestimators.py

@@ -1,5 +1,11 @@
+import warnings
+import numpy as np
+from nose.tools import assert_true, assert_false
 from sklearn.utils.metaestimators import if_delegate_has_method
-from nose.tools import assert_true
+from sklearn.linear_model import SGDClassifier
+with warnings.catch_warnings():
+    warnings.simplefilter('ignore')
+    from sklearn.grid_search import GridSearchCV
 
 
 class Prefix(object):
@@ -24,3 +30,87 @@ def test_delegated_docstring():
                 in str(MockMetaEstimator.func.__doc__))
     assert_true("This is a mock delegated function"
                 in str(MockMetaEstimator().func.__doc__))
+
+
+def test_stochastic_gradient_loss_param():
+    # Make sure the predict_proba works when loss is specified
+    # as one of the parameters in the param_grid.
+    param_grid = {
+        'loss': ['log'],
+    }
+    X = np.arange(20).reshape(5, -1)
+    y = [0, 0, 1, 1, 1]
+    clf = GridSearchCV(estimator=SGDClassifier(loss='hinge'),
+                       param_grid=param_grid)
+
+    # When the estimator is not fitted, `predict_proba` is not available as the
+    # loss is 'hinge'.
+    assert_false(hasattr(clf, "predict_proba"))
+    clf.fit(X, y)
+    clf.predict_proba(X)
+    clf.predict_log_proba(X)
+
+    # Make sure `predict_proba` is not available when setting loss=['hinge']
+    # in param_grid
+    param_grid = {
+        'loss': ['hinge'],
+    }
+    clf = GridSearchCV(estimator=SGDClassifier(loss='hinge'),
+                       param_grid=param_grid)
+    assert_false(hasattr(clf, "predict_proba"))
+    clf.fit(X, y)
+    assert_false(hasattr(clf, "predict_proba"))
+
+
+class MetaEst(object):
+    """A mock meta estimator"""
+    def __init__(self, sub_est, better_sub_est=None):
+        self.sub_est = sub_est
+        self.better_sub_est = better_sub_est
+
+    @if_delegate_has_method(delegate='sub_est')
+    def predict(self):
+        pass
+
+
+class MetaEstTestTuple(MetaEst):
+    """A mock meta estimator to test passing a tuple of delegates"""
+
+    @if_delegate_has_method(delegate=('sub_est', 'better_sub_est'))
+    def predict(self):
+        pass
+
+
+class MetaEstTestList(MetaEst):
+    """A mock meta estimator to test passing a list of delegates"""
+
+    @if_delegate_has_method(delegate=['sub_est', 'better_sub_est'])
+    def predict(self):
+        pass
+
+
+class HasPredict(object):
+    """A mock sub-estimator with predict method"""
+
+    def predict(self):
+        pass
+
+
+class HasNoPredict(object):
+    """A mock sub-estimator with no predict method"""
+    pass
+
+
+def test_if_delegate_has_method():
+    assert_true(hasattr(MetaEst(HasPredict()), 'predict'))
+    assert_false(hasattr(MetaEst(HasNoPredict()), 'predict'))
+    assert_false(
+        hasattr(MetaEstTestTuple(HasNoPredict(), HasNoPredict()), 'predict'))
+    assert_true(
+        hasattr(MetaEstTestTuple(HasPredict(), HasNoPredict()), 'predict'))
+    assert_false(
+        hasattr(MetaEstTestTuple(HasNoPredict(), HasPredict()), 'predict'))
+    assert_false(
+        hasattr(MetaEstTestList(HasNoPredict(), HasPredict()), 'predict'))
+    assert_true(
+        hasattr(MetaEstTestList(HasPredict(), HasPredict()), 'predict'))