title: Using StandardScaler as Preprocessor in Mlens Pipeline generates Classification Warning
body: <p>I am trying to scale my data within the crossvalidation folds of a MLENs Superlearner pipeline. When I use StandardScaler in the pipeline (as demonstrated below), I receive the following warning:</p>
  <blockquote>
  <p>/miniconda3/envs/r_env/lib/python3.7/site-packages/mlens/parallel/_base_functions.py:226: MetricWarning: [pipeline-1.mlpclassifier.0.2] Could not score pipeline-1.mlpclassifier. Details:
  ValueError(&quot;Classification metrics can't handle a mix of binary and continuous-multioutput targets&quot;)
  (name, inst_name, exc), MetricWarning)</p>
  </blockquote>
  <p>Of note, when I omit the StandardScaler() the warning disappears, but the data is not scaled.</p>
  <pre><code>breast_cancer_data = load_breast_cancer()
  
  X = breast_cancer_data['data']
  y = breast_cancer_data['target']
  
  from sklearn.model_selection import train_test_split
  X, X_val, y, y_val = train_test_split(X, y, test_size=.3, random_state=0)
  
  from sklearn.base import BaseEstimator
  class RFBasedFeatureSelector(BaseEstimator):
    
      def __init__(self, n_estimators):
          self.n_estimators = n_estimators
          self.selector = None
  
      def fit(self, X, y):
          clf = RandomForestClassifier(n_estimators=self.n_estimators, random_state = RANDOM_STATE, class_weight = 'balanced')
          clf = clf.fit(X, y)
          self.selector = SelectFromModel(clf, prefit=True, threshold = 0.001)
  
      def transform(self, X):
          if self.selector is None:
              raise AttributeError('The selector attribute has not been assigned. You cannot call transform before first calling fit or fit_transform.')
          return self.selector.transform(X)
  
      def fit_transform(self, X, y):
          self.fit(X, y)
          return self.transform(X)
  
  N_FOLDS = 5
  RF_ESTIMATORS = 1000
  N_ESTIMATORS = 1000
  RANDOM_STATE = 42
  
  from mlens.metrics import make_scorer
  from sklearn.metrics import roc_auc_score, balanced_accuracy_score
  accuracy_scorer = make_scorer(balanced_accuracy_score, average='micro', greater_is_better=True)
  
  from mlens.ensemble.super_learner import SuperLearner
  from sklearn.linear_model import LogisticRegression
  from sklearn.neural_network import MLPClassifier
  from sklearn.ensemble import ExtraTreesClassifier, RandomForestClassifier
  from sklearn.preprocessing import StandardScaler
  from sklearn.feature_selection import SelectFromModel
  
  
  ensemble = SuperLearner(folds=N_FOLDS, shuffle=True, random_state=RANDOM_STATE, n_jobs=10, scorer=balanced_accuracy_score, backend=&quot;multiprocessing&quot;)
  
  preprocessing1 = {'pipeline-1': [StandardScaler()]
                   }
  
  preprocessing2 = {'pipeline-1': [RFBasedFeatureSelector(N_ESTIMATORS)]
                   }
  
  estimators = {'pipeline-1': [RandomForestClassifier(RF_ESTIMATORS, random_state=RANDOM_STATE, class_weight='balanced'), 
                               MLPClassifier(hidden_layer_sizes=(10, 10, 10), activation='relu', solver='sgd',
                                             max_iter=5000)
                                           ]
                   }
  
  ensemble.add(estimators, preprocessing2, preprocessing1)
  
  ensemble.add_meta(LogisticRegression(solver='liblinear', class_weight = 'balanced'))
  
  ensemble.fit(X,y)
  
  yhat = ensemble.predict(X_val)
  balanced_accuracy_score(y_val, yhat)```
  
  &gt;Error text: /miniconda3/envs/r_env/lib/python3.7/site-packages/mlens/parallel/_base_functions.py:226: MetricWarning: [pipeline-1.mlpclassifier.0.2] Could not score pipeline-1.mlpclassifier. Details:
  ValueError(&quot;Classification metrics can't handle a mix of binary and continuous-multioutput targets&quot;)
    (name, inst_name, exc), MetricWarning)
  </code></pre>