class_docstr: SelectByInformationValue() selects features based on their information value (IV).
  The IV is calculated as:
  
   .. math::
  
     IV = ∑ (fraction of positive cases - fraction of negative cases) * WoE
  
  where:
  
  - the fraction of positive cases is the proportion of observations of class 1,
      from the total class 1 observations.
  - the fraction of negative cases is the proportion of observations of class 0,
      from the total class 0 observations.
  - WoE is the weight of the evidence.
  
  SelectByInformationValue() is only suitable to select features for binary
  classification.
  
  SelectByInformationValue() can determine the IV for numerical and categorical
  variables. For numerical variables, it first sorts the variables into intervals,
  and then determines the IV.
  
  You can pass a list of variables to examine. Alternatively, the transformer will
  examine all variables.
  
  The IV allows you to assess each variable's independent contribution to the target
  variable. The transformer selects those variables whose IV is higher than the
  threshold.
  
  More details in the :ref:`User Guide <information_value>`.
  
  
  Parameters
  ----------
  variables: list, default=None
      The list of variables to evaluate. If None, the transformer will evaluate all
      variables in the dataset (except datetime).
  
  bins: int, default = 5
      If the dataset contains numerical variables, the number of bins into which
      the values will be sorted.
  
  strategy: str, default = 'equal_width'
      Whether the bins should be of equal width ('equal_width') or equal frequency
      ('equal_frequency').
  
  threshold: float, int, default = 0.2.
      The threshold to drop a feature. If the IV for a feature is < threshold, the
      feature will be dropped.
  
  {confirm_variables}
  
  Attributes
  ----------
  {variables_}
  
  information_values_:
      A dictionary with the information values for each feature.
  
  {features_to_drop}
  
  {feature_names_in}
  
  {n_features_in}
  
  Methods
  -------
  fit:
      Find features with high information value.
  
  {fit_transform}
  
  {get_support}
  
  transform:
      Remove features with low information value.
  
  See Also
  --------
  feature_engine.encoding.WoEEncoder
  feature_engine.discretisation.EqualWidthDiscretiser
  feature_engine.discretisation.EqualFrequencyDiscretiser
  
  References
  ----------
  .. [1] Weight of evidence and information value explained
      https://www.listendata.com/2015/03/weight-of-evidence-woe-and-information.html
  
  .. [2] WoE and IV for continuous variables
      https://www.listendata.com/2019/08/WOE-IV-Continuous-Dependent.html
docstr: Learn the information value. Find features with IV above the threshold.
  
  Parameters
  ----------
  X: pandas dataframe of shape = [n_samples, n_features]
      The training input samples.
  
  y: pandas series of shape = [n_samples, ]
      Target, must be binary.
docstr_tok: ["Learn","the","information","value",".","Find","features","with","IV","above","the","threshold",".","Parameters","--","--","--","--","--","X",":","pandas","dataframe","of","shape","=","[","n_samples",",","n_features","]","The","training","input","samples",".","y",":","pandas","series","of","shape","=","[","n_samples",",","]","Target",",","must","be","binary","."]
code: def fit(self, X: pd.DataFrame, y: pd.Series):
      """
      Learn the information value. Find features with IV above the threshold.
  
      Parameters
      ----------
      X: pandas dataframe of shape = [n_samples, n_features]
          The training input samples.
  
      y: pandas series of shape = [n_samples, ]
          Target, must be binary.
      """
      # check input dataframe
      X, y = self._check_fit_input(X, y)
  
      # If required exclude variables that are not in the input dataframe
      self._confirm_variables(X)
  
      # find categorical and numerical variables
      # find all variables or check those entered are present in the dataframe
      self.variables_ = _find_all_variables(
          X, self.variables_, exclude_datetime=True
      )
  
      (
          _,
          variables_numerical,
      ) = _find_categorical_and_numerical_variables(X, self.variables_)
  
      # check for missing values
      _check_contains_na(X, self.variables_)
      _check_contains_inf(X, variables_numerical)
  
      # get input df features number and name
      self._get_feature_names_in(X)
  
      # If there are numerical variables, discretize them
      if len(variables_numerical) > 0:
          discretiser = self._make_discretiser(variables_numerical)
          X = discretiser.fit_transform(X)
  
      self.information_values_ = {}
      for var in self.variables_:
          total_pos, total_neg, woe = self._calculate_woe(X, y, var)
          iv = self._calculate_iv(total_pos, total_neg, woe)
          self.information_values_[var] = iv
  
      self.features_to_drop_ = [
          f
          for f in self.information_values_.keys()
          if self.information_values_[f] < self.threshold
      ]
  
      return self
  
imports: from typing import List, Union
  import numpy
  import pandas
  from feature_engine._docstrings.fit_attributes import _feature_names_in_docstring, _n_features_in_docstring, _variables_attribute_docstring
  from feature_engine._docstrings.init_parameters import _ignore_format_docstring
  from feature_engine._docstrings.methods import _fit_transform_docstring
  from feature_engine._docstrings.substitute import Substitution
  from feature_engine._variable_handling.init_parameter_checks import _check_init_parameter_variables
  from feature_engine._variable_handling.variable_type_selection import _find_all_variables, _find_categorical_and_numerical_variables
  from feature_engine.dataframe_checks import _check_contains_inf, _check_contains_na
  from feature_engine.discretisation import EqualFrequencyDiscretiser, EqualWidthDiscretiser
  from feature_engine.encoding.woe import WoE
  from feature_engine.selection._docstring import _features_to_drop_docstring, _get_support_docstring, _threshold_docstring
  from feature_engine.selection.base_selector import BaseSelector
  from feature_engine.tags import _return_tags
label_desc: Use image node_id 2 for calling the SelectByInformationValue obj's underlying member method code with example usage: obj.fit(X, y) and returns: self