class_docstr: Iteratively stratify a multi-label data set into folds
  
  Construct an interative stratifier that splits the data set into folds trying to maintain balanced representation
  with respect to order-th label combinations.
  
  Attributes
  ----------
  
  n_splits : number of splits, int
      the number of folds to stratify into
  
  order : int, >= 1
      the order of label relationship to take into account when balancing sample distribution across labels
  
  sample_distribution_per_fold : None or List[float], :code:`(n_splits)`
      desired percentage of samples in each of the folds, if None and equal distribution of samples per fold
      is assumed i.e. 1/n_splits for each fold. The value is held in :code:`self.percentage_per_fold`.
  
  shuffle : bool
      Whether to shuffle the data before splitting into batches. Note that the samples within each split
      will not be shuffled.
  
  random_state : int, RandomState instance or None
      integer to seed the RNG, or the RNG state to use; if None (the default), will use the global
      state of numpy RNG
docstr: Internal method to distribute evidence for labeled samples across folds
  
  For params, see documentation of :code:`self._prepare_stratification`. Does not return anything,
  modifies params.
docstr_tok: ["Internal","method","to","distribute","evidence","for","labeled","samples","across","folds","For","params",",","see","documentation","of",":","code",":","`","self._prepare_stratification","`",".","Does","not","return","anything",",","modifies","params","."]
code: def _distribute_positive_evidence(
      self,
      rows_used,
      folds,
      samples_with_combination,
      per_row_combinations,
  ):
      """Internal method to distribute evidence for labeled samples across folds
  
      For params, see documentation of :code:`self._prepare_stratification`. Does not return anything,
      modifies params.
      """
      l = _get_most_desired_combination(samples_with_combination)
      while l is not None:
          while len(samples_with_combination[l]) > 0:
              row = samples_with_combination[l].pop()
              if rows_used[row]:
                  continue
  
              max_val = max(
                  self.desired_samples_per_combination_per_fold[l]
              )
              M = np.where(
                  np.array(
                      self.desired_samples_per_combination_per_fold[l]
                  )
                  == max_val
              )[0]
              m = _fold_tie_break(
                  self.desired_samples_per_combination_per_fold[l],
                  M,
                  self._rng_state,
              )
              folds[m].append(row)
              rows_used[row] = True
              for i in per_row_combinations[row]:
                  if row in samples_with_combination[i]:
                      samples_with_combination[i].remove(row)
                  self.desired_samples_per_combination_per_fold[i][
                      m
                  ] -= 1
              self.desired_samples_per_fold[m] -= 1
  
          l = _get_most_desired_combination(samples_with_combination)
  
file_path: scikit-multilearn/skmultilearn/model_selection/iterative_stratification.py
imports: from sklearn.model_selection._split import _BaseKFold
  import numpy
  import scipy.sparse
  import itertools
  from sklearn.utils import check_random_state
label_desc: Use image node_id 3 for calling the IterativeStratification obj's underlying member method code with example usage: obj._distribute_positive_evidence(rows_used, folds, samples_with_combination, per_row_combinations) without return types