| from typing import List |
|
|
| from .card import TaskCard |
| from .dataclass import InternalField, OptionalField |
| from .formats import ICLFormat |
| from .instructions import Instruction |
| from .operator import SourceSequntialOperator, StreamingOperator |
| from .operators import StreamRefiner |
| from .recipe import Recipe |
| from .renderers import StandardRenderer |
| from .schema import ToUnitxtGroup |
| from .splitters import Sampler, SeparateSplit, SpreadSplit |
| from .templates import Template |
|
|
|
|
| class BaseRecipe(Recipe, SourceSequntialOperator): |
| card: TaskCard |
| template: Template = None |
| instruction: Instruction = None |
| format: ICLFormat = ICLFormat() |
|
|
| max_train_instances: int = None |
| max_validation_instances: int = None |
| max_test_instances: int = None |
|
|
| train_refiner: StreamRefiner = OptionalField(default_factory=lambda: StreamRefiner(apply_to_streams=["train"])) |
| validation_refiner: StreamRefiner = OptionalField( |
| default_factory=lambda: StreamRefiner(apply_to_streams=["validation"]) |
| ) |
| test_refiner: StreamRefiner = OptionalField(default_factory=lambda: StreamRefiner(apply_to_streams=["test"])) |
|
|
| demos_pool_size: int = None |
| num_demos: int = 0 |
|
|
| demos_pool_name: str = "demos_pool" |
| demos_taken_from: str = "train" |
| demos_field: str = "demos" |
| sampler: Sampler = None |
|
|
| steps: List[StreamingOperator] = InternalField(default_factory=list) |
|
|
| def verify(self): |
| super().verify() |
| if self.num_demos > 0: |
| if self.demos_pool_size is None or self.demos_pool_size < 1: |
| raise ValueError( |
| "When using demonstrations both num_demos and demos_pool_size should be assigned with postive integers." |
| ) |
| if self.demos_pool_size < self.num_demos: |
| raise ValueError( |
| f"demos_pool_size must be bigger than num_demos={self.num_demos}, Got demos_pool_size={self.demos_pool_size}" |
| ) |
|
|
| def prepare(self): |
| self.steps = [ |
| self.card.loader, |
| ] |
|
|
| if self.card.preprocess_steps is not None: |
| self.steps.extend(self.card.preprocess_steps) |
|
|
| self.steps.append(self.card.task) |
|
|
| if self.demos_pool_size is not None: |
| self.steps.append( |
| SeparateSplit( |
| from_split=self.demos_taken_from, |
| to_split_names=[self.demos_pool_name, self.demos_taken_from], |
| to_split_sizes=[int(self.demos_pool_size)], |
| ) |
| ) |
|
|
| if self.num_demos > 0: |
| sampler = self.card.sampler |
|
|
| if self.sampler is not None: |
| sampler = self.sampler |
|
|
| sampler.set_size(self.num_demos) |
|
|
| self.steps.append( |
| SpreadSplit( |
| source_stream=self.demos_pool_name, |
| target_field=self.demos_field, |
| sampler=sampler, |
| ) |
| ) |
|
|
| self.train_refiner.max_instances = self.max_train_instances |
| self.steps.append(self.train_refiner) |
|
|
| self.validation_refiner.max_instances = self.max_validation_instances |
| self.steps.append(self.validation_refiner) |
|
|
| self.test_refiner.max_instances = self.max_test_instances |
| self.steps.append(self.test_refiner) |
|
|
| render = StandardRenderer( |
| instruction=self.instruction, |
| template=self.template, |
| format=self.format, |
| demos_field=self.demos_field, |
| ) |
|
|
| self.steps.append(render) |
|
|
| postprocessors = render.get_postprocessors() |
|
|
| self.steps.append( |
| ToUnitxtGroup( |
| group="unitxt", |
| metrics=self.card.task.metrics, |
| postprocessors=postprocessors, |
| ) |
| ) |
|
|
|
|
| class StandardRecipeWithIndexes(BaseRecipe): |
| instruction_card_index: int = None |
| template_card_index: int = None |
|
|
| def prepare(self): |
| assert ( |
| self.template_card_index is None or self.template is None |
| ), "Specify either template or template_card_index" |
| if self.template_card_index is not None: |
| self.template = self.card.templates[int(self.template_card_index)] |
|
|
| assert ( |
| self.instruction_card_index is None or self.instruction is None |
| ), "Specify either instruction or instruction_card_index" |
| if self.instruction_card_index is not None: |
| self.instruction = self.card.instructions[int(self.instruction_card_index)] |
|
|
| super().prepare() |
|
|
|
|
| class StandardRecipe(StandardRecipeWithIndexes): |
| """ |
| This class represents a standard recipe for data processing and preperation. |
| This class can be used to prepare a recipe |
| with all necessary steps, refiners and renderers included. It allows to set various |
| parameters and steps in a sequential manner for preparing the recipe. |
| |
| Attributes: |
| card (TaskCard): TaskCard object associated with the recipe. |
| template (Template, optional): Template object to be used for the recipe. |
| instruction (Instruction, optional): Instruction object to be used for the recipe. |
| format (ICLFormat, optional): ICLFormat object to be used for the recipe. |
| train_refiner (StreamRefiner, optional): Train refiner to be used in the recipe. |
| max_train_instances (int, optional): Maximum training instances for the refiner. |
| validation_refiner (StreamRefiner, optional): Validation refiner to be used in the recipe. |
| max_validation_instances (int, optional): Maximum validation instances for the refiner. |
| test_refiner (StreamRefiner, optional): Test refiner to be used in the recipe. |
| max_test_instances (int, optional): Maximum test instances for the refiner. |
| demos_pool_size (int, optional): Size of the demos pool. |
| num_demos (int, optional): Number of demos to be used. |
| demos_pool_name (str, optional): Name of the demos pool. Default is "demos_pool". |
| demos_taken_from (str, optional): Specifies from where the demos are taken. Default is "train". |
| demos_field (str, optional): Field name for demos. Default is "demos". |
| sampler (Sampler, optional): Sampler object to be used in the recipe. |
| steps (List[StreamingOperator], optional): List of StreamingOperator objects to be used in the recipe. |
| instruction_card_index (int, optional): Index of instruction card to be used |
| for preparing the recipe. |
| template_card_index (int, optional): Index of template card to be used for |
| preparing the recipe. |
| |
| Methods: |
| prepare(): This overridden method is used for preparing the recipe |
| by arranging all the steps, refiners, and renderers in a sequential manner. |
| |
| Raises: |
| AssertionError: If both template and template_card_index, or instruction and instruction_card_index |
| are specified at the same time. |
| """ |
|
|
| pass |
|
|
