class_docstr: Grid search reduction for fair classification or regression.
  
  Grid search is an in-processing technique that can be used for fair
  classification or fair regression. For classification it reduces fair
  classification to a sequence of cost-sensitive classification problems,
  returning the deterministic classifier with the lowest empirical error
  subject to fair classification constraints [#agarwal18]_ among the
  candidates searched. For regression it uses the same priniciple to return a
  deterministic regressor with the lowest empirical error subject to the
  constraint of bounded group loss [#agarwal19]_.
  
  References:
      .. [#agarwal18] `A. Agarwal, A. Beygelzimer, M. Dudik, J. Langford, and
         H. Wallach, "A Reductions Approach to Fair Classification,"
         International Conference on Machine Learning, 2018.
         <https://arxiv.org/abs/1803.02453>`_
      .. [#agarwal19] `A. Agarwal, M. Dudik, and Z. Wu, "Fair Regression:
         Quantitative Definitions and Reduction-based Algorithms,"
         International Conference on Machine Learning, 2019.
         <https://arxiv.org/abs/1905.12843>`_
docstr: Train a less biased classifier or regressor with the given training
  data.
  
  Args:
      X (pandas.DataFrame): Training samples.
      y (array-like): Training output.
  
  Returns:
      self
code: def fit(self, X, y):
      """Train a less biased classifier or regressor with the given training
      data.
  
      Args:
          X (pandas.DataFrame): Training samples.
          y (array-like): Training output.
  
      Returns:
          self
      """
      self.estimator_ = clone(self.estimator)
  
      moments = {
          "DemographicParity": red.DemographicParity,
          "EqualizedOdds": red.EqualizedOdds,
          "TruePositiveRateParity": red.TruePositiveRateParity,
          "FalsePositiveRateParity": red.FalsePositiveRateParity,
          "ErrorRateParity": red.ErrorRateParity,
          "BoundedGroupLoss": red.BoundedGroupLoss,
      }
      if isinstance(self.constraints, str):
          if self.constraints not in moments:
              raise ValueError(
                  f"Constraint not recognized: {self.constraints}"
              )
          if self.constraints == "BoundedGroupLoss":
              losses = {
                  "ZeroOne": red.ZeroOneLoss,
                  "Square": red.SquareLoss,
                  "Absolute": red.AbsoluteLoss,
              }
              if self.loss == "ZeroOne":
                  self.loss_ = losses[self.loss]()
              else:
                  self.loss_ = losses[self.loss](
                      self.min_val, self.max_val
                  )
  
              self.moment_ = moments[self.constraints](loss=self.loss_)
          else:
              self.moment_ = moments[self.constraints]()
      elif isinstance(self.constraints, red.Moment):
          self.moment_ = self.constraints
      else:
          raise ValueError(
              "constraints must be a string or Moment object."
          )
  
      self.model_ = red.GridSearch(
          estimator=self.estimator_,
          constraints=self.moment_,
          constraint_weight=self.constraint_weight,
          grid_size=self.grid_size,
          grid_limit=self.grid_limit,
          grid=self.grid,
      )
  
      A = X[self.prot_attr]
  
      if self.drop_prot_attr:
          X = X.drop(self.prot_attr, axis=1)
  
      if isinstance(self.model_.constraints, red.ClassificationMoment):
          le = LabelEncoder()
          y = le.fit_transform(y)
          self.classes_ = le.classes_
  
      self.model_.fit(X, y, sensitive_features=A)
  
      return self
  
file_path: AIF360/aif360/sklearn/inprocessing/grid_search_reduction.py
imports: from sklearn.base import BaseEstimator, ClassifierMixin, clone
  from sklearn.preprocessing import LabelEncoder
label_desc: Use image node_id 2 for calling the GridSearchReduction obj's underlying member method code with example usage: obj.fit(X, y) and returns: self