code: def _fit(self, X=None, y=None, **fit_params_steps):
      self.steps = list(self.steps)
      self._validate_steps()
  
      # Save the incoming feature names (if pandas objects)
      if hasattr(X, "columns"):
          self._feature_names_in = list(X.columns) + (
              [y.name] if hasattr(y, "name") else []
          )
  
      for step_idx, name, transformer in self._iter(
          False, False, False
      ):
          if transformer is None or transformer == "passthrough":
              with _print_elapsed_time(
                  "Pipeline", self._log_message(step_idx)
              ):
                  continue
  
          if hasattr(transformer, "transform"):
              if (
                  self._memory_fit.__class__.__name__
                  == "NotMemorizedFunc"
              ):
                  # Don't clone when caching is disabled to
                  # preserve backward compatibility
                  cloned = transformer
              else:
                  cloned = clone(transformer)
  
              if hasattr(cloned, "_cache_full_transform"):
                  cloned._cache_full_transform = False
  
              # Fit or load the current transformer from cache
              fitted_transformer = self._memory_fit(
                  transformer=cloned,
                  X=X,
                  y=y,
                  message=self._log_message(step_idx),
                  **fit_params_steps.get(name, {}),
              )
              X, y = self._memory_transform(
                  transformer=fitted_transformer,
                  X=X,
                  y=y,
              )
  
          # Replace the transformer of the step with the fitted
          # transformer (necessary when loading from the cache)
          self.steps[step_idx] = (name, fitted_transformer)
  
      if self._final_estimator == "passthrough":
          return X, y, {}
  
      return X, y, fit_params_steps.get(self.steps[-1][0], {})
  
imports: import platform
  import warnings
  from copy import deepcopy
  from inspect import signature
  import imblearn.pipeline
  import sklearn.pipeline
  from sklearn.base import clone
  from sklearn.utils import _print_elapsed_time
  from sklearn.utils.metaestimators import available_if
  from sklearn.utils.validation import check_memory
  from pycaret.utils._show_versions import _get_deps_info
  from pycaret.utils.generic import get_all_object_vars_and_properties, variable_return
label_desc: Use image node_id 11 for calling the Pipeline obj's underlying member method code with example usage: obj._fit(X, y) and returns: X,  y,  fit_params_steps, X,  y,  dict