| from abc import abstractmethod |
| from typing import Dict, Generator, List, Optional, Union |
|
|
| from .dataclass import NonPositionalField |
| from .error_utils import error_context |
| from .logging_utils import get_logger |
| from .operator import SourceOperator |
| from .random_utils import new_random_generator |
| from .stream import DynamicStream, MultiStream |
| from .type_utils import isoftype |
|
|
| logger = get_logger() |
|
|
|
|
| class BaseFusion(SourceOperator): |
| """BaseFusion operator that combines multiple multistreams into one. |
| |
| Args: |
| subsets: a dict of named SourceOperator objects (each to yield a MultiStream) or a list thereof, |
| each is specified along with its input, so can generate a MultiStream |
| include_splits: List of splits to include from each input MultiStream. |
| If None, all splits are included. |
| """ |
|
|
| subsets: Union[List[SourceOperator], Dict[str, SourceOperator]] |
| include_splits: Optional[List[str]] = NonPositionalField(default=None) |
|
|
| @abstractmethod |
| def fusion_generator(self, split) -> Generator: |
| pass |
|
|
| def prepare_subsets(self): |
| assert isoftype(self.subsets, Dict[str, SourceOperator]) or isoftype( |
| self.subsets, List[SourceOperator] |
| ) |
| self.named_subsets = {} |
| if isinstance(self.subsets, list): |
| for i in range(len(self.subsets)): |
| self.named_subsets[i] = self.subsets[i] |
| else: |
| self.named_subsets = self.subsets |
|
|
| def splits(self) -> List[str]: |
| self.prepare_subsets() |
| if self.include_splits is not None: |
| return self.include_splits |
| return ["train", "test", "validation"] |
|
|
| def process( |
| self, |
| ) -> MultiStream: |
| result = {} |
| for split in self.splits(): |
| result[split] = DynamicStream( |
| self.fusion_generator, gen_kwargs={"split": split} |
| ) |
| return MultiStream(result) |
|
|
|
|
| class FixedFusion(BaseFusion): |
| """FixedFusion operator that combines multiple multistreams into one, limiting the number of instances taken from each split of each input multistream. |
| |
| Args: |
| subsets: Dict of named SourceOperator objects (each to yield a MultiStream), or a list thereof |
| splits: List of splits (stream_names) to include, over all input multistreams. If None, all splits are included. |
| max_instances_per_subset: Number of instances to take from each input split of each input multistream. |
| If None, all instances of each split (that is specified in include_splits) are included in the result. |
| |
| """ |
|
|
| max_instances_per_subset: Optional[int] = None |
| max_instances_per_split: Optional[Dict[str, int]] = None |
|
|
| def prepare(self): |
| super().prepare() |
|
|
| |
| def fusion_generator(self, split) -> Generator: |
| for origin_name, origin in self.named_subsets.items(): |
| multi_stream = origin() |
| if split not in multi_stream: |
| continue |
| emitted_from_this_split = 0 |
| max_from_this_split = None |
| if self.max_instances_per_subset is not None: |
| max_from_this_split = self.max_instances_per_subset |
| if self.max_instances_per_split is not None: |
| max_per_this_split = self.max_instances_per_split.get(split) |
| if max_per_this_split is not None: |
| if max_from_this_split is None: |
| max_from_this_split = max_per_this_split |
| elif max_per_this_split < max_from_this_split: |
| max_from_this_split = max_per_this_split |
|
|
| logger.info(f"Processing {split} from {origin_name}...") |
| with error_context(self, subset=origin_name): |
| for instance in multi_stream[split]: |
| if ( |
| max_from_this_split is not None |
| and emitted_from_this_split >= max_from_this_split |
| ): |
| break |
| if isinstance(origin_name, str): |
| if "subset" not in instance: |
| instance["subset"] = [] |
| instance["subset"].insert(0, origin_name) |
| emitted_from_this_split += 1 |
| yield instance |
|
|
|
|
| class WeightedFusion(BaseFusion): |
| """Fusion operator that combines multiple MultiStream-s. |
| |
| Args: |
| subsets: Dict of named MultiStream objects, or a list thereof |
| weights: Dict of named weights for each origin, or a list thereof |
| max_total_examples: Total number of instances to return per returned split. |
| If None, all instances are returned |
| """ |
|
|
| subsets: Union[Dict[str, SourceOperator], List[SourceOperator]] = None |
| weights: Union[Dict[str, Union[float, int]], List[Union[int, float]]] = None |
| max_total_samples: int = None |
|
|
| def verify(self): |
| super().verify() |
| assert self.subsets is not None, "subsets must be specified" |
| assert self.weights is not None, "weights must be specified" |
| assert len(self.subsets) == len( |
| self.weights |
| ), "subsets and weights must have the same length" |
| assert isoftype(self.subsets, Dict[str, SourceOperator]) or isoftype( |
| self.subsets, List[SourceOperator] |
| ) |
| assert isoftype(self.weights, Dict[str, Union[int, float]]) or isoftype( |
| self.weights, List[Union[int, float]] |
| ) |
| assert isinstance(self.subsets, dict) == isinstance(self.weights, dict) |
|
|
| def prepare(self): |
| super().prepare() |
| self.named_weights = ( |
| {i: float(self.weights[i]) for i in range(len(self.weights))} |
| if isinstance(self.weights, list) |
| else {k: float(v) for (k, v) in self.weights.items()} |
| ) |
|
|
| def fusion_generator(self, split) -> Generator: |
| iterators = {} |
| for origin_name, origin in self.named_subsets.items(): |
| multi_stream = origin() |
| if split not in multi_stream: |
| continue |
| iterators[origin_name] = iter(multi_stream[split]) |
| total_examples = 0 |
| random_generator = new_random_generator(sub_seed="weighted_fusion_" + split) |
| while ( |
| self.max_total_samples is None or total_examples < self.max_total_samples |
| ) and len(iterators) > 0: |
| population = list(iterators.keys()) |
| origin_name = random_generator.choices( |
| population=population, |
| weights=[self.named_weights[name] for name in population], |
| )[0] |
| iterator = iterators[origin_name] |
| with error_context(self, subset=origin_name): |
| try: |
| instance = next(iterator) |
| if isinstance(origin_name, str): |
| if "subset" not in instance: |
| instance["subset"] = [] |
| instance["subset"].insert(0, origin_name) |
| total_examples += 1 |
| yield instance |
|
|
| except StopIteration: |
| iterators.pop(origin_name) |
|
|
