5268393053

from typing import (
    Callable,
    Dict,
    Mapping,
    Optional,
    Sequence,
    Tuple,
    TypeVar,
)
from avalanche.benchmarks.scenarios.dataset_scenario import (
    DatasetScenario,
    TStreamsUserDict,
)
from avalanche.benchmarks.scenarios.generic_benchmark_creation import (
    DatasetFactory,
    LazyStreamDefinition,
    create_lazy_generic_benchmark,
    create_multi_dataset_generic_benchmark,
)

from avalanche.benchmarks.utils.transform_groups import XTransform, YTransform
from avalanche.benchmarks.scenarios.detection_scenario import (
    DetectionExperience,
    DetectionScenario,
    DetectionStream,
)
from avalanche.benchmarks.utils.detection_dataset import (
    make_detection_dataset,
    SupportedDetectionDataset,
)


TDatasetScenario = TypeVar(
    'TDatasetScenario',
    bound='DatasetScenario')


def _make_detection_scenario(
    stream_definitions: TStreamsUserDict,
    complete_test_set_only: bool
) -> DetectionScenario[
        DetectionStream[
            DetectionExperience],
        DetectionExperience]:
    return DetectionScenario(
        stream_definitions=stream_definitions,
        complete_test_set_only=complete_test_set_only
    )


def create_multi_dataset_detection_benchmark(
    train_datasets: Sequence[SupportedDetectionDataset],
    test_datasets: Sequence[SupportedDetectionDataset],
    *,
    other_streams_datasets: Optional[
        Mapping[str, Sequence[SupportedDetectionDataset]]] = None,
    complete_test_set_only: bool = False,
    train_transform: XTransform = None,
    train_target_transform: YTransform = None,
    eval_transform: XTransform = None,
    eval_target_transform: YTransform = None,
    other_streams_transforms: Optional[
        Mapping[str, Tuple[XTransform, YTransform]]] = None,
    dataset_factory: DatasetFactory = make_detection_dataset,
    benchmark_factory: Callable[
        [
            TStreamsUserDict,
            bool
        ], TDatasetScenario
    ] = _make_detection_scenario  # type: ignore
) -> TDatasetScenario:
    """
    Creates a detection benchmark instance given a list of datasets.
    Each dataset will be considered as a separate experience.

    Contents of the datasets must already be set, including task labels.
    Transformations will be applied if defined.

    For additional info, please refer to
    :func:`create_multi_dataset_generic_benchmark`.
    """
    return create_multi_dataset_generic_benchmark(
        train_datasets=train_datasets,
        test_datasets=test_datasets,
        other_streams_datasets=other_streams_datasets,
        complete_test_set_only=complete_test_set_only,
        train_transform=train_transform,
        train_target_transform=train_target_transform,
        eval_transform=eval_transform,
        eval_target_transform=eval_target_transform,
        other_streams_transforms=other_streams_transforms,
        dataset_factory=dataset_factory,
        benchmark_factory=benchmark_factory
    )


def create_lazy_detection_benchmark(
    train_generator: LazyStreamDefinition,
    test_generator: LazyStreamDefinition,
    *,
    other_streams_generators: Optional[Dict[str, LazyStreamDefinition]] = None,
    complete_test_set_only: bool = False,
    train_transform: XTransform = None,
    train_target_transform: YTransform = None,
    eval_transform: XTransform = None,
    eval_target_transform: YTransform = None,
    other_streams_transforms: Optional[
        Mapping[str, Tuple[XTransform, YTransform]]] = None,
    dataset_factory: DatasetFactory = make_detection_dataset,
    benchmark_factory: Callable[
        [
            TStreamsUserDict,
            bool
        ], TDatasetScenario
    ] = _make_detection_scenario  # type: ignore
) -> TDatasetScenario:
    """
    Creates a lazily-defined detection benchmark instance given a dataset
    generator for each stream.

    Generators must return properly initialized instances of
    :class:`AvalancheDataset` which will be used to create experiences.

    For additional info, please refer to :func:`create_lazy_generic_benchmark`.
    """
    return create_lazy_generic_benchmark(
        train_generator=train_generator,
        test_generator=test_generator,
        other_streams_generators=other_streams_generators,
        complete_test_set_only=complete_test_set_only,
        train_transform=train_transform,
        train_target_transform=train_target_transform,
        eval_transform=eval_transform,
        eval_target_transform=eval_target_transform,
        other_streams_transforms=other_streams_transforms,
        dataset_factory=dataset_factory,
        benchmark_factory=benchmark_factory
    )


__all__ = [
    'create_multi_dataset_detection_benchmark',
    'create_lazy_detection_benchmark'
]

1	from typing import (	4✔
2	Callable,
3	Dict,
4	Mapping,
5	Optional,
6	Sequence,
7	Tuple,
8	TypeVar,
9	)
10	from avalanche.benchmarks.scenarios.dataset_scenario import (	4✔
11	DatasetScenario,
12	TStreamsUserDict,
13	)
14	from avalanche.benchmarks.scenarios.generic_benchmark_creation import (	4✔
15	DatasetFactory,
16	LazyStreamDefinition,
17	create_lazy_generic_benchmark,
18	create_multi_dataset_generic_benchmark,
19	)
20
21	from avalanche.benchmarks.utils.transform_groups import XTransform, YTransform	4✔
22	from avalanche.benchmarks.scenarios.detection_scenario import (	4✔
23	DetectionExperience,
24	DetectionScenario,
25	DetectionStream,
26	)
27	from avalanche.benchmarks.utils.detection_dataset import (	4✔
28	make_detection_dataset,
29	SupportedDetectionDataset,
30	)
31
32
33	TDatasetScenario = TypeVar(	4✔
34	'TDatasetScenario',
35	bound='DatasetScenario')
36
37
38	def _make_detection_scenario(	4✔
39	stream_definitions: TStreamsUserDict,
40	complete_test_set_only: bool
41	) -> DetectionScenario[
42	DetectionStream[
43	DetectionExperience],
44	DetectionExperience]:
45	return DetectionScenario(	4✔
46	stream_definitions=stream_definitions,
47	complete_test_set_only=complete_test_set_only
48	)
49
50
51	def create_multi_dataset_detection_benchmark(	4✔
52	train_datasets: Sequence[SupportedDetectionDataset],
53	test_datasets: Sequence[SupportedDetectionDataset],
54	*,
55	other_streams_datasets: Optional[
56	Mapping[str, Sequence[SupportedDetectionDataset]]] = None,
57	complete_test_set_only: bool = False,
58	train_transform: XTransform = None,
59	train_target_transform: YTransform = None,
60	eval_transform: XTransform = None,
61	eval_target_transform: YTransform = None,
62	other_streams_transforms: Optional[
63	Mapping[str, Tuple[XTransform, YTransform]]] = None,
64	dataset_factory: DatasetFactory = make_detection_dataset,
65	benchmark_factory: Callable[
66	[
67	TStreamsUserDict,
68	bool
69	], TDatasetScenario
70	] = _make_detection_scenario # type: ignore
71	) -> TDatasetScenario:
72	"""
73	Creates a detection benchmark instance given a list of datasets.
74	Each dataset will be considered as a separate experience.
75
76	Contents of the datasets must already be set, including task labels.
77	Transformations will be applied if defined.
78
79	For additional info, please refer to
80	:func:`create_multi_dataset_generic_benchmark`.
81	"""
82	return create_multi_dataset_generic_benchmark(	4✔
83	train_datasets=train_datasets,
84	test_datasets=test_datasets,
85	other_streams_datasets=other_streams_datasets,
86	complete_test_set_only=complete_test_set_only,
87	train_transform=train_transform,
88	train_target_transform=train_target_transform,
89	eval_transform=eval_transform,
90	eval_target_transform=eval_target_transform,
91	other_streams_transforms=other_streams_transforms,
92	dataset_factory=dataset_factory,
93	benchmark_factory=benchmark_factory
94	)
95
96
97	def create_lazy_detection_benchmark(	4✔
98	train_generator: LazyStreamDefinition,
99	test_generator: LazyStreamDefinition,
100	*,
101	other_streams_generators: Optional[Dict[str, LazyStreamDefinition]] = None,
102	complete_test_set_only: bool = False,
103	train_transform: XTransform = None,
104	train_target_transform: YTransform = None,
105	eval_transform: XTransform = None,
106	eval_target_transform: YTransform = None,
107	other_streams_transforms: Optional[
108	Mapping[str, Tuple[XTransform, YTransform]]] = None,
109	dataset_factory: DatasetFactory = make_detection_dataset,
110	benchmark_factory: Callable[
111	[
112	TStreamsUserDict,
113	bool
114	], TDatasetScenario
115	] = _make_detection_scenario # type: ignore
116	) -> TDatasetScenario:
117	"""
118	Creates a lazily-defined detection benchmark instance given a dataset
119	generator for each stream.
120
121	Generators must return properly initialized instances of
122	:class:`AvalancheDataset` which will be used to create experiences.
123
124	For additional info, please refer to :func:`create_lazy_generic_benchmark`.
125	"""
NEW 126	return create_lazy_generic_benchmark(	×
127	train_generator=train_generator,
128	test_generator=test_generator,
129	other_streams_generators=other_streams_generators,
130	complete_test_set_only=complete_test_set_only,
131	train_transform=train_transform,
132	train_target_transform=train_target_transform,
133	eval_transform=eval_transform,
134	eval_target_transform=eval_target_transform,
135	other_streams_transforms=other_streams_transforms,
136	dataset_factory=dataset_factory,
137	benchmark_factory=benchmark_factory
138	)
139
140
141	__all__ = [	4✔
142	'create_multi_dataset_detection_benchmark',
143	'create_lazy_detection_benchmark'
144	]

ContinualAI / avalanche / 5268393053

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous