###############################################################################

 class BaseEstimator(object):

     """Base class for all estimators in scikit-learn

     Notes

     -----

     All estimators should specify all the parameters that can be set

     at the class level in their __init__ as explicit keyword

     arguments (no *args, **kwargs).

     """

     @classmethod

     def _get_param_names(cls):

         """Get parameter names for the estimator"""

         try:

             # fetch the constructor or the original constructor before

             # deprecation wrapping if any

             init = getattr(cls.__init__, 'deprecated_original', cls.__init__)

             # introspect the constructor arguments to find the model parameters

             # to represent

             args, varargs, kw, default = inspect.getargspec(init)

             if not varargs is None:

                 raise RuntimeError("scikit-learn estimators should always "

                                    "specify their parameters in the signature"

                                    " of their __init__ (no varargs)."

                                    " %s doesn't follow this convention."

                                    % (cls, ))

             # Remove 'self'

             # XXX: This is going to fail if the init is a staticmethod, but

             # who would do this?

             args.pop(0)

         except TypeError:

             # No explicit __init__

             args = []

         args.sort()

         return args

     def get_params(self, deep=True):

         """Get parameters for this estimator.

         Parameters

         ----------

         deep: boolean, optional

             If True, will return the parameters for this estimator and

             contained subobjects that are estimators.

         Returns

         -------

         params : mapping of string to any

             Parameter names mapped to their values.

         """

         out = dict()

         for key in self._get_param_names():

             # We need deprecation warnings to always be on in order to

             # catch deprecated param values.

             # This is set in utils/__init__.py but it gets overwritten

             # when running under python3 somehow.

             warnings.simplefilter("always", DeprecationWarning)

             try:

                 with warnings.catch_warnings(record=True) as w:

                     value = getattr(self, key, None)

                 if len(w) and w[0].category == DeprecationWarning:

                 # if the parameter is deprecated, don't show it

                     continue

             finally:

                 warnings.filters.pop(0)

             # XXX: should we rather test if instance of estimator?

             if deep and hasattr(value, 'get_params'):

                 deep_items = value.get_params().items()

                 out.update((key + '__' + k, val) for k, val in deep_items)

             out[key] = value

         return out

     def set_params(self, **params):

         """Set the parameters of this estimator.

         The method works on simple estimators as well as on nested objects

         (such as pipelines). The former have parameters of the form

         ``<component>__<parameter>`` so that it's possible to update each

         component of a nested object.

         Returns

         -------

         self

         """

         if not params:

             # Simple optimisation to gain speed (inspect is slow)

             return self

         valid_params = self.get_params(deep=True)

         for key, value in six.iteritems(params):

             split = key.split('__', 1)

             if len(split) > 1:

                 # nested objects case

                 name, sub_name = split

                 if not name in valid_params:

                     raise ValueError('Invalid parameter %s for estimator %s' %

                                      (name, self))

                 sub_object = valid_params[name]

                 sub_object.set_params(**{sub_name: value})

             else:

                 # simple objects case

                 if not key in valid_params:

                     raise ValueError('Invalid parameter %s ' 'for estimator %s'

                                      % (key, self.__class__.__name__))

                 setattr(self, key, value)

         return self

     def __repr__(self):

         class_name = self.__class__.__name__

         return '%s(%s)' % (class_name, _pprint(self.get_params(deep=False),

                                                offset=len(class_name),),)

     def __str__(self):

         class_name = self.__class__.__name__

         return '%s(%s)' % (class_name,

                            _pprint(self.get_params(deep=True),

                                    offset=len(class_name), printer=str,),)