class_docstr: Model selection across several estimators and preprocessing pipelines.
  
  The :class:`Evaluator` allows users to evaluate several models in one call
  across a set preprocessing pipelines. The class is useful for comparing
  a set of estimators, especially when several preprocessing pipelines is to
  be evaluated. By pre-making all folds and iteratively fitting estimators
  with different parameter settings, array slicing and preprocessing is kept
  to a minimum. This can greatly reduced fit time compared to
  creating pipeline classes for each estimator and pipeline and fitting them
  one at a time in an Scikit-learn
  :class:`sklearn.model_selection.GridSearch` class.
  
  Preprocessing can be done before making any evaluation, and several
  evaluations can be made on the pre-made folds. Current implementation
  relies on a randomized grid search, so parameter grids must be specified as
  SciPy distributions (or a class that accepts an ``rvs`` method).
  
  .. versionchanged:: 0.2.0
  
  Parameters
  ----------
  scorer : function
      a scoring function that follows the Scikit-learn API::
  
          score = scorer(estimator, y_true, y_pred)
  
      A user defines scoring function, ``score = f(y_true, y_pred)`` can be
      made into a scorer by calling on the ML-Ensemble implementation of
      Scikit-learn's ``make_scorer``. NOTE: do **not** use Scikit-learn's
      ``make_scorer`` if the Evaluator is to be pickled. ::
  
          from mlens.metrics import make_scorer
          scorer = make_scorer(scoring_function, **kwargs)
  
  error_score : int, optional
      score to assign when fitting an estimator fails. If ``None``, the
      evaluator will raise an error.
  
  cv : int or obj, default = 2
      cross validation folds to use. Either pass a ``KFold`` class
      that obeys the Scikit-learn API.
  
  metrics : list, optional
      list of aggregation metrics to calculate on scores. Default is
      mean and standard deviation.
  
  shuffle : bool, default = True
      whether to shuffle input data before creating cv folds.
  
  random_state : int, optional
      seed for creating folds (if shuffled) and parameter draws
  
  n_jobs: int, default = -1
      number of CPU cores to use.
  
  verbose : bool or int, default = False
      level of printed messages. Levels:
  
          #. ``verbose=1``: Message at start and end with total time
          #. ``verbose=2``: Additional messages for each sub-job \
             (preprocess and evaluation)
          #. ``verbose in [3, 14]``: Additional messages with job \
             completion status at increasing increasing frequency
          #. ``Verbose >= 15``: prints each job completed as \
             [case].[est].[draw].[fold]
  
      If ``verbose>=20``, prints to ``sys.stderr``, else ``sys.stdout``.
docstr: Print initiation message and return timer.
docstr_tok: ["Print","initiation","message","and","return","timer","."]
code: def _print_eval_start(self):
      """Print initiation message and return timer."""
      preprocessing = getattr(self, "_preprocessing", None)
  
      if preprocessing is None:
          msg = (
              "Evaluating %i models for %i parameter draws over %i "
              "CV folds, totalling %i fits"
          )
  
          e, c, tot = self._get_count(preprocessing)
          return msg % (e, self.n_iter, c, tot)
      else:
          msg = (
              "Evaluating %i models for %i parameter draws over %i"
              + " preprocessing pipelines and %i CV folds, "
              "totalling %i fits"
          )
  
          e, p, c, tot = self._get_count(preprocessing)
          return msg % (e, self.n_iter, p, c, tot)
  
imports: from __future__ import division, with_statement
  import warnings
  import numpy
  from ._base_functions import parse_key, set_job, cat, check_scorer, make_learners, make_tansformers, check_instances
  from ..index import FoldIndex
  from ..parallel import ParallelEvaluation
  from ..parallel.base import BaseBackend, IndexMixin
  from ..metrics import Data, assemble_data
  from ..utils.formatting import _flatten, _check_instances
  from ..utils import print_time, safe_print, assert_correct_format
  from ..externals.joblib import delayed
  from ..externals.sklearn.base import clone
label_desc: Use image node_id 10 for calling the Evaluator obj's underlying member method code with example usage: obj._print_eval_start() and returns: unknown, unknown