code: def create_generic_benchmark_from_paths(
      train_lists_of_files: Sequence[Sequence[FileAndLabel]],
      test_lists_of_files: Sequence[Sequence[FileAndLabel]],
      *,
      other_streams_lists_of_files: Optional[
          Dict[str, Sequence[Sequence[FileAndLabel]]]
      ] = 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 sequence of lists of files. A separate
      dataset will be created for each list. Each of those datasets
      will be considered a separate experience.
  
      This is very similar to :func:`create_generic_benchmark_from_filelists`,
      with the main difference being that
      :func:`create_generic_benchmark_from_filelists` accepts, for each
      experience, a file list formatted in Caffe-style. On the contrary, this
      accepts a list of tuples where each tuple contains two elements: the full
      path to the pattern and its label. Optionally, the tuple may contain a third
      element describing the bounding box of the element to crop. This last
      bounding box may be useful when trying to extract the part of the image
      depicting the desired element.
  
      Apart from that, the same limitations of
      :func:`create_generic_benchmark_from_filelists` regarding task labels apply.
  
      The label of each pattern doesn't have to be an int. Also, a dataset type
      can be defined.
  
      :param train_lists_of_files: A list of lists. Each list describes the paths
          and labels of patterns to include in that training experience, as
          tuples. Each tuple must contain two elements: the full path to the
          pattern and its class label. Optionally, the tuple may contain a
          third element describing the bounding box to use for cropping (top,
          left, height, width).
      :param test_lists_of_files: A list of lists. Each list describes the paths
          and labels of patterns to include in that test experience, as tuples.
          Each tuple must contain two elements: the full path to the pattern
          and its class label. Optionally, the tuple may contain a third element
          describing the bounding box to use for cropping (top, left, height,
          width).
      :param other_streams_lists_of_files: 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 follow the same structure
          of `train_lists_of_files` and `test_lists_of_files` parameters. If this
          dictionary contains the definition for "train" or "test" streams then
          those definition will  override the `train_lists_of_files` and
          `test_lists_of_files` 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_list_of_files``
          parameter must define a single experience (the complete test set).
          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_lists_of_files, test=test_lists_of_files
      )
  
      if other_streams_lists_of_files is not None:
          input_streams = {
              **input_streams,
              **other_streams_lists_of_files,
          }
  
      stream_definitions: Dict[
          str, Sequence[TaskAwareClassificationDataset]
      ] = dict()
  
      for stream_name, lists_of_files in input_streams.items():
          stream_datasets: List[TaskAwareClassificationDataset] = []
          for exp_id, list_of_files in enumerate(lists_of_files):
              common_root, exp_paths_list = common_paths_root(
                  list_of_files
              )
              paths_dataset: PathsDataset[Any, int] = PathsDataset(
                  common_root, exp_paths_list
              )
              stream_datasets.append(
                  _make_taskaware_classification_dataset(
                      paths_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 5 for calling a global function with example usage: create_generic_benchmark_from_paths(train_lists_of_files, test_lists_of_files) and returns: create_multi_dataset_generic_benchmark