class_docstr: An easy-interpretable classifier optimizing simple logical rules.
  
  Parameters
  ----------
  
  feature_names : list of str, optional
      The names of each feature to be used for returning rules in string
      format.
  
  precision_min : float, optional (default=0.5)
      The minimal precision of a rule to be selected.
  
  recall_min : float, optional (default=0.01)
      The minimal recall of a rule to be selected.
  
  n_estimators : int, optional (default=10)
      The number of base estimators (rules) to use for prediction. More are
      built before selection. All are available in the estimators_ attribute.
  
  max_samples : int or float, optional (default=.8)
      The number of samples to draw from X to train each decision tree, from
      which rules are generated and selected.
          - If int, then draw `max_samples` samples.
          - If float, then draw `max_samples * X.shape[0]` samples.
      If max_samples is larger than the number of samples provided,
      all samples will be used for all trees (no sampling).
  
  max_samples_features : int or float, optional (default=1.0)
      The number of features to draw from X to train each decision tree, from
      which rules are generated and selected.
          - If int, then draw `max_features` features.
          - If float, then draw `max_features * X.shape[1]` features.
  
  bootstrap : boolean, optional (default=False)
      Whether samples are drawn with replacement.
  
  bootstrap_features : boolean, optional (default=False)
      Whether features are drawn with replacement.
  
  max_depth : integer or List or None, optional (default=3)
      The maximum depth of the decision trees. If None, then nodes are
      expanded until all leaves are pure or until all leaves contain less
      than min_samples_split samples.
      If an iterable is passed, you will train n_estimators
      for each tree depth. It allows you to create and compare
      rules of different length.
  
  max_depth_duplication : integer, optional (default=None)
      The maximum depth of the decision tree for rule deduplication,
      if None then no deduplication occurs.
  
  max_features : int, float, string or None, optional (default="auto")
      The number of features considered (by each decision tree) when looking
      for the best split:
  
      - If int, then consider `max_features` features at each split.
      - If float, then `max_features` is a percentage and
        `int(max_features * n_features)` features are considered at each
        split.
      - If "auto", then `max_features=sqrt(n_features)`.
      - If "sqrt", then `max_features=sqrt(n_features)` (same as "auto").
      - If "log2", then `max_features=log2(n_features)`.
      - If None, then `max_features=n_features`.
  
      Note: the search for a split does not stop until at least one
      valid partition of the node samples is found, even if it requires to
      effectively inspect more than ``max_features`` features.
  
  min_samples_split : int, float, optional (default=2)
      The minimum number of samples required to split an internal node for
      each decision tree.
          - If int, then consider `min_samples_split` as the minimum number.
          - If float, then `min_samples_split` is a percentage and
            `ceil(min_samples_split * n_samples)` are the minimum
            number of samples for each split.
  
  n_jobs : integer, optional (default=1)
      The number of jobs to run in parallel for both `fit` and `predict`.
      If -1, then the number of jobs is set to the number of cores.
  
  random_state : int, RandomState instance or None, optional
      - If int, random_state is the seed used by the random number generator.
      - If RandomState instance, random_state is the random number generator.
      - If None, the random number generator is the RandomState instance used
      by `np.random`.
  
  verbose : int, optional (default=0)
      Controls the verbosity of the tree building process.
  
  Attributes
  ----------
  rules_ : dict of tuples (rule, precision, recall, nb).
      The collection of `n_estimators` rules used in the ``predict`` method.
      The rules are generated by fitted sub-estimators (decision trees). Each
      rule satisfies recall_min and precision_min conditions. The selection
      is done according to OOB precisions.
  
  estimators_ : list of DecisionTreeClassifier
      The collection of fitted sub-estimators used to generate candidate
      rules.
  
  estimators_samples_ : list of arrays
      The subset of drawn samples (i.e., the in-bag samples) for each base
      estimator.
  
  estimators_features_ : list of arrays
      The subset of drawn features for each base estimator.
  
  max_samples_ : integer
      The actual number of samples
  
  n_features_ : integer
      The number of features when ``fit`` is performed.
  
  classes_ : array, shape (n_classes,)
      The classes labels.
class_docstr_tok: ["An","easy-interpretable","classifier","optimizing","simple","logical","rules",".","Parameters","--","--","--","--","--","feature_names",":","list","of","str",",","optional","The","names","of","each","feature","to","be","used","for","returning","rules","in","string","format",".","precision_min",":","float",",","optional","(","default=0.5",")","The","minimal","precision","of","a","rule","to","be","selected",".","recall_min",":","float",",","optional","(","default=0.01",")","The","minimal","recall","of","a","rule","to","be","selected",".","n_estimators",":","int",",","optional","(","default=10",")","The","number","of","base","estimators","(","rules",")","to","use","for","prediction",".","More","are","built","before","selection",".","All","are","available","in","the","estimators_","attribute",".","max_samples",":","int","or","float",",","optional","(","default=.8",")","The","number","of","samples","to","draw","from","X","to","train","each","decision","tree",",","from","which","rules","are","generated","and","selected",".","-","If","int",",","then","draw","`","max_samples","`","samples",".","-","If","float",",","then","draw","`","max_samples","*","X.shape","[","0","]","`","samples",".","If","max_samples","is","larger","than","the","number","of","samples","provided",",","all","samples","will","be","used","for","all","trees","(","no","sampling",")",".","max_samples_features",":","int","or","float",",","optional","(","default=1.0",")","The","number","of","features","to","draw","from","X","to","train","each","decision","tree",",","from","which","rules","are","generated","and","selected",".","-","If","int",",","then","draw","`","max_features","`","features",".","-","If","float",",","then","draw","`","max_features","*","X.shape","[","1","]","`","features",".","bootstrap",":","boolean",",","optional","(","default=False",")","Whether","samples","are","drawn","with","replacement",".","bootstrap_features",":","boolean",",","optional","(","default=False",")","Whether","features","are","drawn","with","replacement",".","max_depth",":","integer","or","List","or","None",",","optional","(","default=3",")","The","maximum","depth","of","the","decision","trees",".","If","None",",","then","nodes","are","expanded","until","all","leaves","are","pure","or","until","all","leaves","contain","less","than","min_samples_split","samples",".","If","an","iterable","is","passed",",","you","will","train","n_estimators","for","each","tree","depth",".","It","allows","you","to","create","and","compare","rules","of","different","length",".","max_depth_duplication",":","integer",",","optional","(","default=None",")","The","maximum","depth","of","the","decision","tree","for","rule","deduplication",",","if","None","then","no","deduplication","occurs",".","max_features",":","int",",","float",",","string","or","None",",","optional","(","default=","''","auto","''",")","The","number","of","features","considered","(","by","each","decision","tree",")","when","looking","for","the","best","split",":","-","If","int",",","then","consider","`","max_features","`","features","at","each","split",".","-","If","float",",","then","`","max_features","`","is","a","percentage","and","`","int","(","max_features","*","n_features",")","`","features","are","considered","at","each","split",".","-","If","``","auto","''",",","then","`","max_features=sqrt","(","n_features",")","`",".","-","If","``","sqrt","''",",","then","`","max_features=sqrt","(","n_features",")","`","(","same","as","``","auto","''",")",".","-","If","``","log2","''",",","then","`","max_features=log2","(","n_features",")","`",".","-","If","None",",","then","`","max_features=n_features","`",".","Note",":","the","search","for","a","split","does","not","stop","until","at","least","one","valid","partition","of","the","node","samples","is","found",",","even","if","it","requires","to","effectively","inspect","more","than","``","max_features","``","features",".","min_samples_split",":","int",",","float",",","optional","(","default=2",")","The","minimum","number","of","samples","required","to","split","an","internal","node","for","each","decision","tree",".","-","If","int",",","then","consider","`","min_samples_split","`","as","the","minimum","number",".","-","If","float",",","then","`","min_samples_split","`","is","a","percentage","and","`","ceil","(","min_samples_split","*","n_samples",")","`","are","the","minimum","number","of","samples","for","each","split",".","n_jobs",":","integer",",","optional","(","default=1",")","The","number","of","jobs","to","run","in","parallel","for","both","`","fit","`","and","`","predict","`",".","If","-1",",","then","the","number","of","jobs","is","set","to","the","number","of","cores",".","random_state",":","int",",","RandomState","instance","or","None",",","optional","-","If","int",",","random_state","is","the","seed","used","by","the","random","number","generator",".","-","If","RandomState","instance",",","random_state","is","the","random","number","generator",".","-","If","None",",","the","random","number","generator","is","the","RandomState","instance","used","by","`","np.random","`",".","verbose",":","int",",","optional","(","default=0",")","Controls","the","verbosity","of","the","tree","building","process",".","Attributes","--","--","--","--","--","rules_",":","dict","of","tuples","(","rule",",","precision",",","recall",",","nb",")",".","The","collection","of","`","n_estimators","`","rules","used","in","the","``","predict","``","method",".","The","rules","are","generated","by","fitted","sub-estimators","(","decision","trees",")",".","Each","rule","satisfies","recall_min","and","precision_min","conditions",".","The","selection","is","done","according","to","OOB","precisions",".","estimators_",":","list","of","DecisionTreeClassifier","The","collection","of","fitted","sub-estimators","used","to","generate","candidate","rules",".","estimators_samples_",":","list","of","arrays","The","subset","of","drawn","samples","(","i.e.",",","the","in-bag","samples",")","for","each","base","estimator",".","estimators_features_",":","list","of","arrays","The","subset","of","drawn","features","for","each","base","estimator",".","max_samples_",":","integer","The","actual","number","of","samples","n_features_",":","integer","The","number","of","features","when","``","fit","``","is","performed",".","classes_",":","array",",","shape","(","n_classes",",",")","The","classes","labels","."]
docstr: Fit the model according to the given training data.
  
  Parameters
  ----------
  X : array-like, shape (n_samples, n_features)
      Training vector, where n_samples is the number of samples and
      n_features is the number of features.
  
  y : array-like, shape (n_samples,)
      Target vector relative to X. Has to follow the convention 0 for
      normal data, 1 for anomalies.
  
  sample_weight : array-like, shape (n_samples,) optional
      Array of weights that are assigned to individual samples, typically
      the amount in case of transactions data. Used to grow regression
      trees producing further rules to be tested.
      If not provided, then each sample is given unit weight.
  
  Returns
  -------
  self : object
      Returns self.
docstr_tok: ["Fit","the","model","according","to","the","given","training","data",".","Parameters","--","--","--","--","--","X",":","array-like",",","shape","(","n_samples",",","n_features",")","Training","vector",",","where","n_samples","is","the","number","of","samples","and","n_features","is","the","number","of","features",".","y",":","array-like",",","shape","(","n_samples",",",")","Target","vector","relative","to","X",".","Has","to","follow","the","convention","0","for","normal","data",",","1","for","anomalies",".","sample_weight",":","array-like",",","shape","(","n_samples",",",")","optional","Array","of","weights","that","are","assigned","to","individual","samples",",","typically","the","amount","in","case","of","transactions","data",".","Used","to","grow","regression","trees","producing","further","rules","to","be","tested",".","If","not","provided",",","then","each","sample","is","given","unit","weight",".","Returns","--","--","--","-","self",":","object","Returns","self","."]
code: def fit(self, X, y, sample_weight=None):
      """Fit the model according to the given training data.
  
      Parameters
      ----------
      X : array-like, shape (n_samples, n_features)
          Training vector, where n_samples is the number of samples and
          n_features is the number of features.
  
      y : array-like, shape (n_samples,)
          Target vector relative to X. Has to follow the convention 0 for
          normal data, 1 for anomalies.
  
      sample_weight : array-like, shape (n_samples,) optional
          Array of weights that are assigned to individual samples, typically
          the amount in case of transactions data. Used to grow regression
          trees producing further rules to be tested.
          If not provided, then each sample is given unit weight.
  
      Returns
      -------
      self : object
          Returns self.
      """
  
      X, y = check_X_y(X, y)
      check_classification_targets(y)
      self.n_features_ = X.shape[1]
  
      self.classes_ = np.unique(y)
      n_classes = len(self.classes_)
  
      if n_classes < 2:
          raise ValueError(
              "This method needs samples of at least 2 classes"
              " in the data, but the data contains only one"
              " class: %r" % self.classes_[0]
          )
  
      if (
          not isinstance(self.max_depth_duplication, int)
          and self.max_depth_duplication is not None
      ):
          raise ValueError("max_depth_duplication should be an integer")
      if not set(self.classes_) == set([0, 1]):
          warn(
              "Found labels %s. This method assumes target class to be"
              " labeled as 1 and normal data to be labeled as 0. Any label"
              " different from 0 will be considered as being from the"
              " target class." % set(self.classes_)
          )
          y = y > 0
  
      # ensure that max_samples is in [1, n_samples]:
      n_samples = X.shape[0]
  
      if isinstance(self.max_samples, str):
          raise ValueError(
              "max_samples (%s) is not supported."
              'Valid choices are: "auto", int or'
              "float" % self.max_samples
          )
  
      elif isinstance(self.max_samples, INTEGER_TYPES):
          if self.max_samples > n_samples:
              warn(
                  "max_samples (%s) is greater than the "
                  "total number of samples (%s). max_samples "
                  "will be set to n_samples for estimation."
                  % (self.max_samples, n_samples)
              )
              max_samples = n_samples
          else:
              max_samples = self.max_samples
      else:  # float
          if not (0.0 < self.max_samples <= 1.0):
              raise ValueError(
                  "max_samples must be in (0, 1], got %r"
                  % self.max_samples
              )
          max_samples = int(self.max_samples * X.shape[0])
  
      self.max_samples_ = max_samples
  
      self.rules_ = {}
      self.estimators_ = []
      self.estimators_samples_ = []
      self.estimators_features_ = []
  
      # default columns names :
      feature_names_ = [
          BASE_FEATURE_NAME + x
          for x in np.arange(X.shape[1]).astype(str)
      ]
      if self.feature_names is not None:
          self.feature_dict_ = {
              BASE_FEATURE_NAME + str(i): feat
              for i, feat in enumerate(self.feature_names)
          }
      else:
          self.feature_dict_ = {
              BASE_FEATURE_NAME + str(i): feat
              for i, feat in enumerate(feature_names_)
          }
      self.feature_names_ = feature_names_
  
      clfs = []
      regs = []
  
      self._max_depths = (
          self.max_depth
          if isinstance(self.max_depth, Iterable)
          else [self.max_depth]
      )
  
      for max_depth in self._max_depths:
          bagging_clf = BaggingClassifier(
              base_estimator=DecisionTreeClassifier(
                  max_depth=max_depth,
                  max_features=self.max_features,
                  min_samples_split=self.min_samples_split,
              ),
              n_estimators=self.n_estimators,
              max_samples=self.max_samples_,
              max_features=self.max_samples_features,
              bootstrap=self.bootstrap,
              bootstrap_features=self.bootstrap_features,
              # oob_score=... XXX may be added
              # if selection on tree perf needed.
              # warm_start=... XXX may be added to increase computation perf.
              n_jobs=self.n_jobs,
              random_state=self.random_state,
              verbose=self.verbose,
          )
  
          bagging_reg = BaggingRegressor(
              base_estimator=DecisionTreeRegressor(
                  max_depth=max_depth,
                  max_features=self.max_features,
                  min_samples_split=self.min_samples_split,
              ),
              n_estimators=self.n_estimators,
              max_samples=self.max_samples_,
              max_features=self.max_samples_features,
              bootstrap=self.bootstrap,
              bootstrap_features=self.bootstrap_features,
              # oob_score=... XXX may be added
              # if selection on tree perf needed.
              # warm_start=... XXX may be added to increase computation perf.
              n_jobs=self.n_jobs,
              random_state=self.random_state,
              verbose=self.verbose,
          )
  
          clfs.append(bagging_clf)
          regs.append(bagging_reg)
  
      # define regression target:
      if sample_weight is not None:
          if sample_weight is not None:
              sample_weight = check_array(
                  sample_weight, ensure_2d=False
              )
          weights = sample_weight - sample_weight.min()
          contamination = float(sum(y)) / len(y)
          y_reg = pow(weights, 0.5) * 0.5 / contamination * (
              y > 0
          ) - pow((weights).mean(), 0.5) * (y == 0)
          y_reg = 1.0 / (1 + np.exp(-y_reg))  # sigmoid
      else:
          y_reg = y  # same as an other classification bagging
  
      for clf in clfs:
          clf.fit(X, y)
          self.estimators_ += clf.estimators_
          self.estimators_samples_ += clf.estimators_samples_
          self.estimators_features_ += clf.estimators_features_
  
      for reg in regs:
          reg.fit(X, y_reg)
          self.estimators_ += reg.estimators_
          self.estimators_samples_ += reg.estimators_samples_
          self.estimators_features_ += reg.estimators_features_
  
      rules_ = []
      for estimator, samples, features in zip(
          self.estimators_,
          self.estimators_samples_,
          self.estimators_features_,
      ):
          # Create mask for OOB samples
          mask = ~indices_to_mask(samples, n_samples)
  
          if sum(mask) == 0:
              warn(
                  "OOB evaluation not possible: doing it in-bag."
                  " Performance evaluation is likely to be wrong"
                  " (overfitting) and selected rules are likely to"
                  " not perform well! Please use max_samples < 1."
              )
              mask = samples
          rules_from_tree = self._tree_to_rules(
              estimator, np.array(self.feature_names_)[features]
          )
  
          # XXX todo: idem without dataframe
          X_oob = pandas.DataFrame(
              (X[mask, :])[:, features],
              columns=np.array(self.feature_names_)[features],
          )
  
          if (
              X_oob.shape[1] > 1
          ):  # otherwise pandas bug (cf. issue #16363)
              y_oob = y[mask]
              y_oob = np.array((y_oob != 0))
  
              # Add OOB performances to rules:
              rules_from_tree = [
                  (r, self._eval_rule_perf(r, X_oob, y_oob))
                  for r in set(rules_from_tree)
              ]
              rules_ += rules_from_tree
  
      # Factorize rules before semantic tree filtering
      rules_ = [
          tuple(rule)
          for rule in [Rule(r, args=args) for r, args in rules_]
      ]
  
      # keep only rules verifying precision_min and recall_min:
      for rule, score in rules_:
          if (
              score[0] >= self.precision_min
              and score[1] >= self.recall_min
          ):
              if rule in self.rules_:
                  # update the score to the new mean
                  c = self.rules_[rule][2] + 1
                  b = self.rules_[rule][1] + 1.0 / c * (
                      score[1] - self.rules_[rule][1]
                  )
                  a = self.rules_[rule][0] + 1.0 / c * (
                      score[0] - self.rules_[rule][0]
                  )
  
                  self.rules_[rule] = (a, b, c)
              else:
                  self.rules_[rule] = (score[0], score[1], 1)
  
      self.rules_ = sorted(
          self.rules_.items(),
          key=lambda x: (x[1][0], x[1][1]),
          reverse=True,
      )
  
      # Deduplicate the rule using semantic tree
      if self.max_depth_duplication is not None:
          self.rules_ = self.deduplicate(self.rules_)
  
      self.rules_ = sorted(self.rules_, key=lambda x: -self.f1_score(x))
      self.rules_without_feature_names_ = self.rules_
  
      # Replace generic feature names by real feature names
      self.rules_ = [
          (replace_feature_name(rule, self.feature_dict_), perf)
          for rule, perf in self.rules_
      ]
  
      return self
  
imports: import numpy
  from collections import Counter
  from collections.abc import Iterable
  import pandas
  import numbers
  from warnings import warn
  from sklearn.base import BaseEstimator
  from sklearn.utils.validation import check_X_y, check_array, check_is_fitted
  from sklearn.utils.multiclass import check_classification_targets
  from sklearn.utils import indices_to_mask
  from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor
  from sklearn.ensemble import BaggingClassifier, BaggingRegressor
  from sklearn.tree import _tree
  from .rule import Rule, replace_feature_name
label_desc: Use image node_id 2 for calling the SkopeRules obj's underlying member method code with example usage: obj.fit(X, y, sample_weight) and returns: self