code: def ni_benchmark(
      train_dataset: Union[
          Sequence[SupportedDataset], SupportedDataset
      ],
      test_dataset: Union[Sequence[SupportedDataset], SupportedDataset],
      n_experiences: int,
      *,
      task_labels: bool = False,
      shuffle: bool = True,
      seed: Optional[int] = None,
      balance_experiences: bool = False,
      min_class_patterns_in_exp: int = 0,
      fixed_exp_assignment: Optional[Sequence[Sequence[int]]] = None,
      train_transform=None,
      eval_transform=None,
      reproducibility_data: Optional[Dict[str, Any]] = None,
  ) -> NIScenario:
      """
      This is the high-level benchmark instances generator for the
      "New Instances" (NI) case. Given a sequence of train and test datasets
      creates the continual stream of data as a series of experiences.
  
      This is the reference helper function for creating instances of
      Domain-Incremental benchmarks.
  
      The ``task_labels`` parameter determines if each incremental experience has
      an increasing task label or if, at the contrary, a default task label 0
      has to be assigned to all experiences. This can be useful when
      differentiating between Single-Incremental-Task and Multi-Task scenarios.
  
      There are other important parameters that can be specified in order to tweak
      the behaviour of the resulting benchmark. Please take a few minutes to read
      and understand them as they may save you a lot of work.
  
      This generator features an integrated reproducibility mechanism that allows
      the user to store and later re-load a benchmark. For more info see the
      ``reproducibility_data`` parameter.
  
      :param train_dataset: A list of training datasets, or a single dataset.
      :param test_dataset: A list of test datasets, or a single test dataset.
      :param n_experiences: The number of experiences.
      :param task_labels: If True, each experience will have an ascending task
              label. If False, the task label will be 0 for all the experiences.
      :param shuffle: If True, patterns order will be shuffled.
      :param seed: A valid int used to initialize the random number generator.
          Can be None.
      :param balance_experiences: If True, pattern of each class will be equally
          spread across all experiences. If False, patterns will be assigned to
          experiences in a complete random way. Defaults to False.
      :param min_class_patterns_in_exp: The minimum amount of patterns of
          every class that must be assigned to every experience. Compatible with
          the ``balance_experiences`` parameter. An exception will be raised if
          this constraint can't be satisfied. Defaults to 0.
      :param fixed_exp_assignment: If not None, the pattern assignment
          to use. It must be a list with an entry for each experience. Each entry
          is a list that contains the indexes of patterns belonging to that
          experience. Overrides the ``shuffle``, ``balance_experiences`` and
          ``min_class_patterns_in_exp`` parameters.
      :param train_transform: The transformation to apply to the training data,
          e.g. a random crop, a normalization or a concatenation of different
          transformations (see torchvision.transform documentation for a
          comprehensive list of possible transformations). Defaults to None.
      :param eval_transform: The transformation to apply to the test data,
          e.g. a random crop, a normalization or a concatenation of different
          transformations (see torchvision.transform documentation for a
          comprehensive list of possible transformations). Defaults to None.
      :param reproducibility_data: If not None, overrides all the other
          benchmark definition options, including ``fixed_exp_assignment``.
          This is usually a dictionary containing data used to
          reproduce a specific experiment. One can use the
          ``get_reproducibility_data`` method to get (and even distribute)
          the experiment setup so that it can be loaded by passing it as this
          parameter. In this way one can be sure that the same specific
          experimental setup is being used (for reproducibility purposes).
          Beware that, in order to reproduce an experiment, the same train and
          test datasets must be used. Defaults to None.
  
      :return: A properly initialized :class:`NIScenario` instance.
      """
  
      seq_train_dataset, seq_test_dataset = train_dataset, test_dataset
      if isinstance(train_dataset, (list, tuple)):
          if not isinstance(test_dataset, (list, tuple)):
              raise ValueError(
                  "If a list is passed for train_dataset, "
                  "then test_dataset must be a list, too."
              )
  
          if len(train_dataset) != len(test_dataset):
              raise ValueError(
                  "Train/test dataset lists must contain the "
                  "exact same number of datasets"
              )
  
          train_dataset_sup = list(
              map(
                  _as_taskaware_supervised_classification_dataset,
                  train_dataset,
              )
          )
          test_dataset_sup = list(
              map(
                  _as_taskaware_supervised_classification_dataset,
                  test_dataset,
              )
          )
  
          (
              seq_train_dataset,
              seq_test_dataset,
              _,
          ) = _concat_taskaware_classification_datasets_sequentially(
              train_dataset_sup, test_dataset_sup
          )
      else:
          seq_train_dataset = (
              _as_taskaware_supervised_classification_dataset(
                  train_dataset
              )
          )
          seq_test_dataset = (
              _as_taskaware_supervised_classification_dataset(
                  test_dataset
              )
          )
  
      transform_groups = dict(
          train=(train_transform, None), eval=(eval_transform, None)
      )
  
      # Set transformation groups
      final_train_dataset = _make_taskaware_classification_dataset(
          seq_train_dataset,
          transform_groups=transform_groups,
          initial_transform_group="train",
      )
  
      final_test_dataset = _make_taskaware_classification_dataset(
          seq_test_dataset,
          transform_groups=transform_groups,
          initial_transform_group="eval",
      )
  
      return NIScenario(
          train_dataset=final_train_dataset,
          test_dataset=final_test_dataset,
          n_experiences=n_experiences,
          task_labels=task_labels,
          shuffle=shuffle,
          seed=seed,
          balance_experiences=balance_experiences,
          min_class_patterns_in_exp=min_class_patterns_in_exp,
          fixed_exp_assignment=fixed_exp_assignment,
          reproducibility_data=reproducibility_data,
      )
  
file_path: avalanche/avalanche/benchmarks/scenarios/deprecated/generators.py
imports: from typing import TYPE_CHECKING, Sequence, Optional, Dict, TypeVar, Union, Any, List, Callable, Set, Tuple
  import torch
  from avalanche.benchmarks.scenarios.dataset_scenario import split_validation_random
  from avalanche.benchmarks.scenarios.deprecated.classification_scenario import ClassificationScenario
  from avalanche.benchmarks.scenarios.deprecated.dataset_scenario import DatasetScenario, DatasetStream, FactoryBasedStream, StreamDef, TStreamsUserDict
  from avalanche.benchmarks.scenarios.detection_scenario import DetectionScenario
  from avalanche.benchmarks.scenarios.deprecated.generic_benchmark_creation import *
  from avalanche.benchmarks.scenarios.deprecated import DatasetExperience
  from avalanche.benchmarks.scenarios.deprecated.lazy_dataset_sequence import LazyDatasetSequence
  from avalanche.benchmarks.scenarios.deprecated.new_classes.nc_scenario import NCScenario
  from avalanche.benchmarks.scenarios.deprecated.new_instances.ni_scenario import NIScenario
  from avalanche.benchmarks.scenarios.online import FixedSizeExperienceSplitter
  from avalanche.benchmarks.utils.classification_dataset import SupportedDataset, _as_taskaware_supervised_classification_dataset, _make_taskaware_classification_dataset, _concat_taskaware_classification_datasets_sequentially
label_desc: Use image node_id 2 for calling a global function with example usage: ni_benchmark(train_dataset, test_dataset, n_experiences) and returns: NIScenario