code: def binary_downsample(
      dataset: Dataset,
      ratio: float = 0.0,
      seed: int = 42,
      label_column: str = "label",
      *,
      do_correction: bool = True,
  ) -> Dataset:
      """Downsamples a given dataset to the specified negative to positive examples ratio. Only works with
      binary classification datasets with labels denoted as `0` and `1`.
      Args:
          dataset: a Dataset to downsample
          ratio: negative to positive examples ratio to maintain
          seed: a seed for shuffling
          label_column: the name of `label` column such as 'label' or 'labels'
          do_correction: correct resampled indices. If indices aren't corrected then examples with mismatched
          indices will not be accounted for be ReCoRD metrics. This is not necessarily undesirable because
          examples with such indices will have less negative examples (or even none), which makes them easier
          for the model, thus inflating the resulting metrics.
      Returns:
          Dataset: a downsampled dataset
      """
  
      def replace_indices(
          data: Dataset, index_map: Dict[str, str]
      ) -> Dict[str, List[str]]:
          idx: List[str] = [index_map.get(el, el) for el in data["idx"]]
          return {"idx": idx}
  
      def get_correct_indices_map(data: Dataset) -> Dict[str, str]:
          """Generate a dictionary with replacements for indices that
          are no longer correct due to downsampling (i.e. the total number
          of elements denoted by the last part of an index has changed)
          Args:
              data: a downsampled Dataset
          Returns:
              Dict[str, str]: a dictionary containing replacement indices
          """
          actual_n_elements: Counter = Counter(data["idx"])
          corrected_index_map: Dict[str, str] = dict()
          for idx, n_elements in actual_n_elements.items():
              expected_n_elements: int = int(idx.split("-")[-1])
              if expected_n_elements != n_elements:
                  new_idx: List[str] = idx.split("-")
                  new_idx[-1]: str = str(n_elements)
                  new_idx: str = "-".join(new_idx)
                  corrected_index_map[idx] = new_idx
          return corrected_index_map
  
      def correct_indices(data: Dataset) -> Dataset:
          """Sets correct number of examples in downsampled indices
          Args:
              data: a downsampled dataset
          Returns:
              Dataset: the same dataset with correct indices
          """
          index_map: Dict[str, str] = get_correct_indices_map(data)
          return data.map(
              replace_indices,
              batched=True,
              fn_kwargs={"index_map": index_map},
          )
  
      dataset_labels = dataset.unique(label_column)
      # `test` split shouldn't be downsampled
      if dataset_labels == [-1]:
          return dataset
      elif set(dataset_labels) == {0, 1}:
          # positive examples are denoted with `1`
          num_positive: int = sum(dataset[label_column])
          num_total: int = len(dataset)
          # the original number of negative examples is returned if `ratio` is not explicitly specified
          num_negative: int = floor(
              num_positive * ratio
              if ratio > 0
              else num_total - num_positive
          )
          # first `num_positive` examples in a sorted dataset are labeled with `1`
          # while the rest are labeled with `0`
          sorted_dataset: Dataset = dataset.sort(
              label_column, reverse=True
          )
          # but we need to reshuffle the dataset before returning it
          shuffled_dataset: Dataset = sorted_dataset.select(
              range(num_positive + num_negative)
          ).shuffle(seed=seed)
          if do_correction:
              shuffled_dataset = correct_indices(shuffled_dataset)
          return shuffled_dataset
      # the same logic is not applicable to cases with != 2 classes
      else:
          raise ValueError(
              f"Only binary classification labels are supported (i.e. [0, 1]), but {dataset_labels} were given"
          )
  
file_path: DeepPavlov/deeppavlov/dataset_readers/huggingface_dataset_reader.py
imports: import re
  from collections import Counter
  from math import floor
  from typing import Dict, Optional, List, Union
  from datasets import load_dataset, Dataset, Features, ClassLabel, concatenate_datasets
  from deeppavlov.core.common.registry import register
  from deeppavlov.core.data.dataset_reader import DatasetReader
label_desc: Use image node_id 6 for calling a global function with example usage: binary_downsample(dataset, ratio, seed, label_column) and returns: dict, corrected_index_map, data, dataset, shuffled_dataset