| from abc import abstractmethod |
| from typing import Dict, List, Optional, Union |
|
|
| from .dataclass import NonPositionalField |
| from .formats import Format |
| from .fusion import FixedFusion |
| from .operator import SourceOperator |
| from .standard import DatasetRecipe |
| from .stream import MultiStream |
| from .system_prompts import SystemPrompt |
|
|
|
|
| class BaseBenchmark(SourceOperator): |
| format: Format = NonPositionalField(default=None) |
| num_demos: int = NonPositionalField(default=None) |
| system_prompt: SystemPrompt = NonPositionalField(default=None) |
| loader_limit: int = NonPositionalField(default=None) |
| splits: List[str] = NonPositionalField( |
| default_factory=lambda: ["train", "validation", "test"] |
| ) |
| subset: Optional[str] = NonPositionalField(default=None) |
|
|
| @abstractmethod |
| def reset(self): |
| pass |
|
|
|
|
| class Benchmark(BaseBenchmark): |
| subsets: Dict[str, Union[DatasetRecipe, BaseBenchmark]] |
|
|
| max_total_samples: int = None |
| max_samples_per_subset: int = None |
| max_train_instances: int = None |
| max_validation_instances: int = None |
| max_test_instances: int = None |
|
|
| def verify(self): |
| super().verify() |
| if ( |
| self.max_total_samples is not None |
| and self.max_samples_per_subset is not None |
| ): |
| raise ValueError("Set either max_total_samples or max_samples_per_subset") |
|
|
| def prepare_args(self): |
| self.subsets = dict(self.subsets) |
|
|
| def reset(self): |
| if ( |
| self.format is not None |
| or self.num_demos is not None |
| or self.system_prompt is not None |
| or self.loader_limit is not None |
| ): |
| for subset in self.subsets.values(): |
| if self.num_demos is not None: |
| subset.num_demos = self.num_demos |
| if self.format is not None: |
| subset.format = self.format |
| if self.system_prompt is not None: |
| subset.system_prompt = self.system_prompt |
| if self.loader_limit is not None: |
| subset.loader_limit = self.loader_limit |
|
|
| subset.reset() |
|
|
| def prepare(self): |
| super().prepare() |
|
|
| self.reset() |
|
|
| def process( |
| self, |
| ) -> MultiStream: |
| if self.subset is not None: |
| subsets = {self.subset: self.subsets[self.subset]} |
| else: |
| subsets = self.subsets |
|
|
| max_instances_per_split = {} |
| if self.max_train_instances is not None: |
| max_instances_per_split["train"] = self.max_train_instances |
| if self.max_validation_instances is not None: |
| max_instances_per_split["validation"] = self.max_validation_instances |
| if self.max_test_instances is not None: |
| max_instances_per_split["test"] = self.max_test_instances |
| if len(max_instances_per_split) == 0: |
| max_instances_per_split = None |
|
|
| if self.max_total_samples is None: |
| operator = FixedFusion( |
| subsets=subsets, |
| max_instances_per_subset=self.max_samples_per_subset, |
| max_instances_per_split=max_instances_per_split, |
| include_splits=self.splits, |
| ) |
| else: |
| raise NotImplementedError() |
|
|
| return operator() |
|
|
