Upload standard.py with huggingface_hub

standard.py

@@ -1,18 +1,23 @@
-import logging
 from typing import List
 
 from .card import TaskCard
-from .dataclass import InternalField, OptionalField
-from .formats import ICLFormat
-from .instructions import Instruction
+from .dataclass import Field, InternalField, OptionalField
+from .formats import Format, SystemFormat
+from .instructions import EmptyInstruction, Instruction
+from .logging_utils import get_logger
 from .operator import SourceSequentialOperator, StreamingOperator
-from .operators import Augmentor, NullAugmentor, StreamRefiner
+from .operators import (
+    Augmentor,
+    NullAugmentor,
+    StreamRefiner,
+)
 from .recipe import Recipe
-from .renderers import StandardRenderer
 from .schema import ToUnitxtGroup
 from .splitters import Sampler, SeparateSplit, SpreadSplit
 from .templates import Template
 
+logger = get_logger()
+
 
 # Used to give meaningful name to recipe steps
 class CreateDemosPool(SeparateSplit):
@@ -26,8 +31,8 @@ class AddDemosField(SpreadSplit):
 class BaseRecipe(Recipe, SourceSequentialOperator):
     card: TaskCard
     template: Template = None
-    instruction: Instruction = None
-    format: ICLFormat = ICLFormat()
+    instruction: Instruction = Field(default_factory=EmptyInstruction)
+    format: Format = Field(default_factory=SystemFormat)
 
     loader_limit: int = None
 
@@ -51,6 +56,11 @@ class BaseRecipe(Recipe, SourceSequentialOperator):
 
     steps: List[StreamingOperator] = InternalField(default_factory=list)
 
+    def before_process_multi_stream(self):
+        super().before_process_multi_stream()
+        if self.sampler:  # e.g. when num_demos is 0, the sampler may not be initialized
+            self.sampler.init_new_random_generator()
+
     def verify(self):
         super().verify()
         if self.num_demos > 0:
@@ -60,31 +70,31 @@ class BaseRecipe(Recipe, SourceSequentialOperator):
                 )
             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}"
+                    f"num_demos (got: {self.num_demos}) should not exceed demos_pool_size (got: {self.demos_pool_size})"
                 )
             if self.loader_limit and self.demos_pool_size > self.loader_limit:
                 raise ValueError(
-                    f"demos_pool_size must be bigger than loader_limit ({self.loader_limit}), Got demos_pool_size={self.demos_pool_size}"
+                    f"demos_pool_size should not exceed loader_limit ({self.loader_limit}), Got demos_pool_size={self.demos_pool_size}"
                 )
 
         if self.loader_limit:
             if self.max_test_instances and self.max_test_instances > self.loader_limit:
                 raise ValueError(
-                    f"max_test_instances must be bigger than loader_limit ({self.loader_limit}), Got max_test_instances={self.max_test_instances}"
+                    f"max_test_instances should not exceed loader_limit ({self.loader_limit}), Got max_test_instances={self.max_test_instances}"
                 )
             if (
                 self.max_validation_instances
                 and self.max_validation_instances > self.loader_limit
             ):
                 raise ValueError(
-                    f"max_validation_instances must be bigger than loader_limit ({self.loader_limit}), Got max_validation_instances={self.max_validation_instances}"
+                    f"max_validation_instances should not exceed loader_limit ({self.loader_limit}), Got max_validation_instances={self.max_validation_instances}"
                 )
             if (
                 self.max_train_instances
                 and self.max_train_instances > self.loader_limit
             ):
                 raise ValueError(
-                    f"max_train_instances must be bigger than loader_limit ({self.loader_limit}), Got max_train_instances={self.max_train_instances}"
+                    f"max_train_instances should not exceed loader_limit ({self.loader_limit}), Got max_train_instances={self.max_train_instances}"
                 )
 
     def prepare(self):
@@ -94,7 +104,7 @@ class BaseRecipe(Recipe, SourceSequentialOperator):
 
         if self.loader_limit:
             self.card.loader.loader_limit = self.loader_limit
-            logging.info(f"Loader line limit was set to  {self.loader_limit}")
+            logger.info(f"Loader line limit was set to  {self.loader_limit}")
             self.steps.append(StreamRefiner(max_instances=self.loader_limit))
 
         if self.card.preprocess_steps is not None:
@@ -116,20 +126,15 @@ class BaseRecipe(Recipe, SourceSequentialOperator):
             )
 
         if self.num_demos > 0:
-            sampler = self.card.sampler
-
-            if self.sampler is not None:
-                sampler = self.sampler
+            if self.sampler is None:
+                if self.card.sampler is None:
+                    raise ValueError(
+                        "Unexpected None value for card.sampler. "
+                        "To use num_demos > 0, please set a sampler on the TaskCard."
+                    )
+                self.sampler = self.card.sampler
 
-            sampler.set_size(self.num_demos)
-
-            self.steps.append(
-                AddDemosField(
-                    source_stream=self.demos_pool_name,
-                    target_field=self.demos_field,
-                    sampler=sampler,
-                )
-            )
+            self.sampler.set_size(self.num_demos)
 
         self.train_refiner.max_instances = self.max_train_instances
         self.train_refiner.apply_to_streams = ["train"]
@@ -143,19 +148,21 @@ class BaseRecipe(Recipe, SourceSequentialOperator):
         self.test_refiner.apply_to_streams = ["test"]
         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)
-
+        self.steps.append(self.template)
+        if self.num_demos > 0:
+            self.steps.append(
+                AddDemosField(
+                    source_stream=self.demos_pool_name,
+                    target_field=self.demos_field,
+                    sampler=self.sampler,
+                )
+            )
+        self.steps.append(self.instruction)
+        self.steps.append(self.format)
         if self.augmentor.augment_model_input:
             self.steps.append(self.augmentor)
 
-        postprocessors = render.get_postprocessors()
+        postprocessors = self.template.get_postprocessors()
 
         self.steps.append(
             ToUnitxtGroup(
@@ -198,7 +205,7 @@ class StandardRecipeWithIndexes(BaseRecipe):
 
 
 class StandardRecipe(StandardRecipeWithIndexes):
-    """This class represents a standard recipe for data processing and preperation.
+    """This class represents a standard recipe for data processing and preparation.
 
     This class can be used to prepare a recipe.
     with all necessary steps, refiners and renderers included. It allows to set various
@@ -209,7 +216,7 @@ class StandardRecipe(StandardRecipeWithIndexes):
         template (Template, optional): Template object to be used for the recipe.
         instruction (Instruction, optional): Instruction object to be used for the recipe.
         loader_limit (int, optional): Specifies the maximum number of instances per stream to be returned from the loader (used to reduce loading time in large datasets)
-        format (ICLFormat, optional): ICLFormat object to be used for the recipe.
+        format (SystemFormat, optional): SystemFormat 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.