class_docstr: Sklearn-compatible estimator, for reducing the number of features in a dataset to only those,
  that are relevant and significant to a given target. It is basically a wrapper around
  :func:`~tsfresh.feature_selection.feature_selector.check_fs_sig_bh`.
  
  The check is done by testing the hypothesis
  
      :math:`H_0` = the Feature is not relevant and can not be added`
  
  against
  
      :math:`H_1` = the Feature is relevant and should be kept
  
  using several statistical tests (depending on whether the feature or/and the target is binary
  or not). Using the Benjamini Hochberg procedure, only features in :math:`H_0` are rejected.
  
  This estimator - as most of the sklearn estimators - works in a two step procedure. First, it is fitted
  on training data, where the target is known:
  
  >>> import pandas as pd
  >>> X_train, y_train = pd.DataFrame(), pd.Series() # fill in with your features and target
  >>> from tsfresh.transformers import FeatureSelector
  >>> selector = FeatureSelector()
  >>> selector.fit(X_train, y_train)
  
  In this example the list of relevant features is empty:
  
  >>> selector.relevant_features
  >>> []
  
  The same holds for the feature importance:
  
  >>> selector.feature_importances_
  >>> array([], dtype=float64)
  
  The estimator keeps track on those features, that were relevant in the training step. If you
  apply the estimator after the training, it will delete all other features in the testing
  data sample:
  
  >>> X_test = pd.DataFrame()
  >>> X_selected = selector.transform(X_test)
  
  After that, X_selected will only contain the features that were relevant during the training.
  
  If you are interested in more information on the features, you can look into the member
  ``relevant_features`` after the fit.
docstr: Create a new FeatureSelector instance.
  
  :param test_for_binary_target_binary_feature: Which test to be used for binary target, binary feature
                                                (currently unused)
  :type test_for_binary_target_binary_feature: str
  
  :param test_for_binary_target_real_feature: Which test to be used for binary target, real feature
  :type test_for_binary_target_real_feature: str
  
  :param test_for_real_target_binary_feature: Which test to be used for real target, binary feature
                                              (currently unused)
  :type test_for_real_target_binary_feature: str
  
  :param test_for_real_target_real_feature: Which test to be used for real target, real feature (currently unused)
  :type test_for_real_target_real_feature: str
  
  :param fdr_level: The FDR level that should be respected, this is the theoretical expected percentage
                    of irrelevant features among all created features.
  :type fdr_level: float
  
  :param hypotheses_independent: Can the significance of the features be assumed to be independent?
                                 Normally, this should be set to False as the features are never
                                 independent (e.g. mean and median)
  :type hypotheses_independent: bool
  
  :param n_jobs: Number of processes to use during the p-value calculation
  :type n_jobs: int
  
  :param chunksize: Size of the chunks submitted to the worker processes
  :type chunksize: int
  
  :param ml_task: The intended machine learning task. Either `'classification'`, `'regression'` or `'auto'`.
              Defaults to `'auto'`, meaning the intended task is inferred from `y`.
              If `y` has a boolean, integer or object dtype, the task is assumed to be classification,
              else regression.
  :type ml_task: str
  
  :param multiclass: Whether the problem is multiclass classification. This modifies the way in which features
                 are selected. Multiclass requires the features to be statistically significant for
                 predicting n_significant classes.
  :type multiclass: bool
  
  :param n_significant: The number of classes for which features should be statistically significant predictors
                      to be regarded as 'relevant'
  :type n_significant: int
  
  :param multiclass_p_values: The desired method for choosing how to display multiclass p-values for each feature.
                              Either `'avg'`, `'max'`, `'min'`, `'all'`. Defaults to `'min'`, meaning the p-value
                              with the highest significance is chosen. When set to `'all'`, the attributes
                              `self.feature_importances_` and `self.p_values` are of type pandas.DataFrame, where
                              each column corresponds to a target class.
  :type multiclass_p_values: str
code: def __init__(
      self,
      test_for_binary_target_binary_feature=defaults.TEST_FOR_BINARY_TARGET_BINARY_FEATURE,
      test_for_binary_target_real_feature=defaults.TEST_FOR_BINARY_TARGET_REAL_FEATURE,
      test_for_real_target_binary_feature=defaults.TEST_FOR_REAL_TARGET_BINARY_FEATURE,
      test_for_real_target_real_feature=defaults.TEST_FOR_REAL_TARGET_REAL_FEATURE,
      fdr_level=defaults.FDR_LEVEL,
      hypotheses_independent=defaults.HYPOTHESES_INDEPENDENT,
      n_jobs=defaults.N_PROCESSES,
      chunksize=defaults.CHUNKSIZE,
      ml_task="auto",
      multiclass=False,
      n_significant=1,
      multiclass_p_values="min",
  ):
      """
      Create a new FeatureSelector instance.
  
      :param test_for_binary_target_binary_feature: Which test to be used for binary target, binary feature
                                                    (currently unused)
      :type test_for_binary_target_binary_feature: str
  
      :param test_for_binary_target_real_feature: Which test to be used for binary target, real feature
      :type test_for_binary_target_real_feature: str
  
      :param test_for_real_target_binary_feature: Which test to be used for real target, binary feature
                                                  (currently unused)
      :type test_for_real_target_binary_feature: str
  
      :param test_for_real_target_real_feature: Which test to be used for real target, real feature (currently unused)
      :type test_for_real_target_real_feature: str
  
      :param fdr_level: The FDR level that should be respected, this is the theoretical expected percentage
                        of irrelevant features among all created features.
      :type fdr_level: float
  
      :param hypotheses_independent: Can the significance of the features be assumed to be independent?
                                     Normally, this should be set to False as the features are never
                                     independent (e.g. mean and median)
      :type hypotheses_independent: bool
  
      :param n_jobs: Number of processes to use during the p-value calculation
      :type n_jobs: int
  
      :param chunksize: Size of the chunks submitted to the worker processes
      :type chunksize: int
  
      :param ml_task: The intended machine learning task. Either `'classification'`, `'regression'` or `'auto'`.
                  Defaults to `'auto'`, meaning the intended task is inferred from `y`.
                  If `y` has a boolean, integer or object dtype, the task is assumed to be classification,
                  else regression.
      :type ml_task: str
  
      :param multiclass: Whether the problem is multiclass classification. This modifies the way in which features
                     are selected. Multiclass requires the features to be statistically significant for
                     predicting n_significant classes.
      :type multiclass: bool
  
      :param n_significant: The number of classes for which features should be statistically significant predictors
                          to be regarded as 'relevant'
      :type n_significant: int
  
      :param multiclass_p_values: The desired method for choosing how to display multiclass p-values for each feature.
                                  Either `'avg'`, `'max'`, `'min'`, `'all'`. Defaults to `'min'`, meaning the p-value
                                  with the highest significance is chosen. When set to `'all'`, the attributes
                                  `self.feature_importances_` and `self.p_values` are of type pandas.DataFrame, where
                                  each column corresponds to a target class.
      :type multiclass_p_values: str
      """
      self.relevant_features = None
      self.feature_importances_ = None
      self.p_values = None
      self.features = None
  
      self.test_for_binary_target_binary_feature = (
          test_for_binary_target_binary_feature
      )
      self.test_for_binary_target_real_feature = (
          test_for_binary_target_real_feature
      )
      self.test_for_real_target_binary_feature = (
          test_for_real_target_binary_feature
      )
      self.test_for_real_target_real_feature = (
          test_for_real_target_real_feature
      )
  
      self.fdr_level = fdr_level
      self.hypotheses_independent = hypotheses_independent
  
      self.n_jobs = n_jobs
      self.chunksize = chunksize
      self.ml_task = ml_task
      self.multiclass = multiclass
      self.n_significant = n_significant
      self.multiclass_p_values = multiclass_p_values
  
file_path: tsfresh/tsfresh/transformers/feature_selector.py
imports: import pandas
  from sklearn.base import BaseEstimator, TransformerMixin
  from tsfresh import defaults
  from tsfresh.feature_selection.relevance import calculate_relevance_table
label_desc: Use image node_id 1 to create a new FeatureSelector object from inherited base classes: BaseEstimator, TransformerMixin with example: obj = FeatureSelector(test_for_binary_target_binary_feature, test_for_binary_target_real_feature, test_for_real_target_binary_feature, test_for_real_target_real_feature, fdr_level, hypotheses_independent, n_jobs, chunksize, ml_task, multiclass, n_significant, multiclass_p_values)