docs: def fit(self, X, y=None, **kwargs):
          """
          Fits the estimator to discover the feature importances described by
          the data, then draws those importances as a bar plot.
  
          Parameters
          ----------
          X : ndarray or DataFrame of shape n x m
              A matrix of n instances with m features
  
          y : ndarray or Series of length n
              An array or series of target or class values
  
          kwargs : dict
              Keyword arguments passed to the fit method of the estimator.
  
          Returns
          -------
          self : visualizer
              The fit method must always return self to support pipelines.
          """
          super(FeatureImportances, self).fit(X, y, **kwargs)
  
          # Get the feature importances from the model
          self.feature_importances_ = self._find_importances_param()
  
          # Get the classes from the model
          if is_classifier(self):
              self.classes_ = self._find_classes_param()
          else:
              self.classes_ = None
              self.stack = False
  
          # If self.stack = True and feature importances is a multidim array,
          # we're expecting a shape of (n_classes, n_features)
          # therefore we flatten by taking the average by
          # column to get shape (n_features,)  (see LogisticRegression)
          if not self.stack and self.feature_importances_.ndim > 1:
              self.feature_importances_ = np.mean(self.feature_importances_, axis=0)
              warnings.warn((
                  "detected multi-dimensional feature importances but stack=False, "
                  "using mean to aggregate them."
              ), YellowbrickWarning)
  
          # Apply absolute value filter before normalization
          if self.absolute:
              self.feature_importances_ = np.abs(self.feature_importances_)
  
          # Normalize features relative to the maximum
          if self.relative:
              maxv = np.abs(self.feature_importances_).max()
              self.feature_importances_ /= maxv
              self.feature_importances_ *= 100.0
  
          # Create labels for the feature importances
          # NOTE: this code is duplicated from MultiFeatureVisualizer
          if self.labels is None:
              # Use column names if a dataframe
              if is_dataframe(X):
                  self.features_ = np.array(X.columns)
  
              # Otherwise use the column index as the labels
              else:
                  _, ncols = X.shape
                  self.features_ = np.arange(0, ncols)
          else:
              self.features_ = np.array(self.labels)
  
          # Sort the features and their importances
          if self.stack:
              sort_idx = np.argsort(np.mean(self.feature_importances_, 0))
              self.features_ = self.features_[sort_idx]
              self.feature_importances_ = self.feature_importances_[:, sort_idx]
          else:
              sort_idx = np.argsort(self.feature_importances_)
              self.features_ = self.features_[sort_idx]
              self.feature_importances_ = self.feature_importances_[sort_idx]
  
          # Draw the feature importances
          self.draw()
          return self