class_docstr: This pipeline extends the sklearn Pipeline to support transformers that change X, y,
  sample_weight, and the number of samples.
  
  It also adds some new options for setting hyper-parameters with callables and in reference to
  other parameters (see examples).
  
  Parameters
  ----------
  steps : list
      List of (name, transform) tuples (implementing fit/transform) that are chained, in the
      order in which they are chained, with the last object an estimator.
  scorer : sklearn scorer object
  memory : currently not implemented
  
  Attributes
  ----------
  N_train : number of training samples - available after calling fit method
  N_test : number of testing samples - available after calling predict, or score methods
  
  Examples
  --------
  
  >>> from seglearn.transform import FeatureRep, SegmentX
  >>> from seglearn.pipe import Pype
  >>> from seglearn.datasets import load_watch
  >>> from sklearn.ensemble import RandomForestClassifier
  >>> from sklearn.preprocessing import StandardScaler
  >>> data = load_watch()
  >>> X = data['X']
  >>> y = data['y']
  >>> pipe = Pype([('segment', SegmentX()),
  >>>              ('features', FeatureRep()),
  >>>              ('scaler', StandardScaler()),
  >>>              ('rf', RandomForestClassifier())])
  >>> pipe.fit(X, y)
  >>> print(pipe.score(X, y))
code: def _fit(self, X, y=None, **fit_params):
      self.steps = list(self.steps)
      self._validate_steps()
  
      fit_params_steps = dict(
          (name, {}) for name, step in self.steps if step is not None
      )
  
      for pname, pval in fit_params.items():
          step, param = pname.split("__", 1)
          fit_params_steps[step][param] = pval
  
      Xt = X
      yt = y
  
      # iterate through all but last
      for step_idx, (name, transformer) in enumerate(self.steps[:-1]):
          if transformer is None:
              pass
          else:
              # not doing cloning for now...
              if isinstance(transformer, XyTransformerMixin):
                  Xt, yt, _ = transformer.fit_transform(
                      Xt,
                      yt,
                      sample_weight=None,
                      **fit_params_steps[name],
                  )
              else:
                  Xt = transformer.fit_transform(
                      Xt, yt, **fit_params_steps[name]
                  )
  
      if self._final_estimator is None:
          return Xt, yt, {}
      return Xt, yt, fit_params_steps[self.steps[-1][0]]
  
imports: import numpy
  from sklearn.base import BaseEstimator
  from sklearn.pipeline import Pipeline
  from .transform import XyTransformerMixin, Segment
  from .util import segmented_prediction_to_series
label_desc: Use image node_id 3 for calling the Pype obj's underlying member method code with example usage: obj._fit(X, y) and returns: Xt,  yt,  fit_params_steps, Xt,  yt,  dict