code: def create_generic_benchmark_from_filelists(
      root: Optional[Union[str, Path]],
      train_file_lists: Sequence[Union[str, Path]],
      test_file_lists: Sequence[Union[str, Path]],
      *,
      other_streams_file_lists: Optional[
          Dict[str, Sequence[Union[str, Path]]]
      ] = None,
      task_labels: Sequence[int],
      complete_test_set_only: bool = False,
      train_transform=None,
      train_target_transform=None,
      eval_transform=None,
      eval_target_transform=None,
      other_streams_transforms: Optional[
          Dict[str, Tuple[Any, Any]]
      ] = None,
  ) -> GenericCLScenario:
      """
      Creates a benchmark instance given a list of filelists and the respective
      task labels. A separate dataset will be created for each filelist and each
      of those datasets will be considered a separate experience.
  
      This helper functions is the best shot when loading Caffe-style dataset
      based on filelists.
  
      Beware that this helper function is limited is the following two aspects:
  
      - The resulting benchmark instance and the intermediate datasets used to
        populate it will be of type CLASSIFICATION. There is no way to change
        this.
      - Task labels can only be defined by choosing a single task label for
        each experience (the same task label is applied to all patterns of
        experiences sharing the same position in different streams).
  
      Despite those constraints, this helper function is usually sufficiently
      powerful to cover most continual learning benchmarks based on file lists.
  
      When in need to create a similar benchmark instance starting from an
      in-memory list of paths, then the similar helper function
      :func:`create_generic_benchmark_from_paths` can be used.
  
      When in need to create a benchmark instance in which task labels are defined
      in a more fine-grained way, then consider using
      :func:`create_multi_dataset_generic_benchmark` by passing properly
      initialized :class:`AvalancheDataset` instances.
  
      :param root: The root path of the dataset. Can be None.
      :param train_file_lists: A list of filelists describing the
          paths of the training patterns for each experience.
      :param test_file_lists: A list of filelists describing the
          paths of the test patterns for each experience.
      :param other_streams_file_lists: A dictionary describing the content of
          custom streams. Keys must be valid stream names (letters and numbers,
          not starting with a number) while the value must be a list of filelists
          (same as `train_file_lists` and `test_file_lists` parameters). If this
          dictionary contains the definition for "train" or "test" streams then
          those definition will  override the `train_file_lists` and
          `test_file_lists` parameters.
      :param task_labels: A list of task labels. Must contain at least a value
          for each experience. Each value describes the task label that will be
          applied to all patterns of a certain experience. For more info on that,
          see the function description.
      :param complete_test_set_only: If True, only the complete test set will
          be returned by the benchmark. This means that the ``test_file_lists``
          parameter must be list with a single element (the complete test set).
          Alternatively, can be a plain string or :class:`Path` object.
          Defaults to False.
      :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 train_target_transform: The transformation to apply to training
          patterns targets. 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 eval_target_transform: The transformation to apply to test
          patterns targets. Defaults to None.
      :param other_streams_transforms: Transformations to apply to custom
          streams. If no transformations are defined for a custom stream,
          then "train" transformations will be used. This parameter must be a
          dictionary mapping stream names to transformations. The transformations
          must be a two elements tuple where the first element defines the
          X transformation while the second element is the Y transformation.
          Those elements can be None. If this dictionary contains the
          transformations for "train" or "test" streams then those transformations
          will override the `train_transform`, `train_target_transform`,
          `eval_transform` and `eval_target_transform` parameters.
  
      :returns: A :class:`GenericCLScenario` instance.
      """
  
      input_streams = dict(train=train_file_lists, test=test_file_lists)
  
      if other_streams_file_lists is not None:
          input_streams = {**input_streams, **other_streams_file_lists}
  
      stream_definitions: Dict[
          str, Sequence[TaskAwareClassificationDataset]
      ] = dict()
  
      for stream_name, file_lists in input_streams.items():
          stream_datasets: List[TaskAwareClassificationDataset] = []
          for exp_id, f_list in enumerate(file_lists):
              f_list_dataset = FilelistDataset(root, f_list)
              stream_datasets.append(
                  _make_taskaware_classification_dataset(
                      f_list_dataset, task_labels=task_labels[exp_id]
                  )
              )
  
          stream_definitions[stream_name] = stream_datasets
  
      return create_multi_dataset_generic_benchmark(
          [],
          [],
          other_streams_datasets=stream_definitions,
          train_transform=train_transform,
          train_target_transform=train_target_transform,
          eval_transform=eval_transform,
          eval_target_transform=eval_target_transform,
          complete_test_set_only=complete_test_set_only,
          other_streams_transforms=other_streams_transforms,
      )
  
file_path: avalanche/avalanche/benchmarks/scenarios/deprecated/generic_benchmark_creation.py
imports: from pathlib import Path
  from typing import Generator, List, Mapping, Sequence, Union, Any, Tuple, Dict, Optional, Iterable, NamedTuple
  from avalanche.benchmarks.utils.classification_dataset import _make_taskaware_tensor_classification_dataset, _make_taskaware_classification_dataset
  from avalanche.benchmarks.utils import SupportedDataset, FilelistDataset, PathsDataset, common_paths_root
  from avalanche.benchmarks.utils.classification_dataset import TaskAwareClassificationDataset
  from avalanche.benchmarks.scenarios.deprecated.classification_scenario import GenericCLScenario
label_desc: Use image node_id 4 for calling a global function with example usage: create_generic_benchmark_from_filelists(root, train_file_lists, test_file_lists) and returns: create_multi_dataset_generic_benchmark