Upload templates.py with huggingface_hub

templates.py

@@ -1,10 +1,10 @@
-import random
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Union
 
 from .artifact import Artifact
-from .instructions import Instruction
+from .instructions import Instruction, TextualInstruction
 from .operator import InstanceOperatorWithGlobalAccess, StreamInstanceOperator
+from .random_utils import random
 from .text_utils import split_words
 
 
@@ -108,16 +108,9 @@ class RenderTemplatedICL(RenderAutoFormatTemplate):
     size_limiter: Artifact = None
     input_output_separator: str = "\n"
     demo_separator: str = "\n\n"
-    demos_cache = None
-
-    def verify(self):
-        assert self.demos_cache is None
 
     def render(self, instance: Dict[str, object]) -> Dict[str, object]:
-        if self.demos_cache is None:
-            self.demos_cache = instance.pop(self.demos_field, [])
-        else:
-            instance.pop(self.demos_field, None)
+        demos = instance.pop(self.demos_field, [])
 
         source = ""
 
@@ -128,7 +121,7 @@ class RenderTemplatedICL(RenderAutoFormatTemplate):
         if self.instruction is not None:
             source += self.instruction_prefix + self.instruction() + self.demo_separator
 
-        for demo_instance in self.demos_cache:
+        for demo_instance in demos:
             demo_example = super().render(demo_instance)
             demo_str = (
                 self.input_prefix
@@ -157,16 +150,39 @@ class InputOutputTemplate(Template):
     input_format: str = None
     output_format: str = None
 
-    def process_inputs(self, inputs: Dict[str, object]) -> Dict[str, object]:
-        return self.input_format.format(**inputs)
+    def process_template(self, template: str, data: Dict[str, object]) -> str:
+        return template.format(**data)
 
-    def process_outputs(self, outputs: Dict[str, object]) -> Dict[str, object]:
-        return self.output_format.format(**outputs)
+    def process_inputs(self, inputs: Dict[str, object]) -> str:
+        try:
+            return self.process_template(self.input_format, inputs)
+        except KeyError as e:
+            raise KeyError(
+                f"Available inputs are {inputs.keys()} but input format requires a different one: {self.input_format}"
+            )
+
+    def process_outputs(self, outputs: Dict[str, object]) -> str:
+        try:
+            return self.process_template(self.output_format, outputs)
+        except KeyError as e:
+            raise KeyError(
+                f"Available inputs are {outputs.keys()} but output format requires a different one: {self.output_format}"
+            )
 
     def get_postprocessors(self) -> List[str]:
         return ["to_string"]
 
 
+class OutputQuantizingTemplate(InputOutputTemplate):
+    quantum: float = 0.1
+
+    def process_outputs(self, outputs: Dict[str, object]) -> Dict[str, object]:
+        quantized_outputs = {
+            key: round(input_float / self.quantum) * self.quantum for key, input_float in outputs.items()
+        }
+        return super().process_outputs(quantized_outputs)
+
+
 class AutoInputOutputTemplate(InputOutputTemplate):
     def infer_input_format(self, inputs):
         input_format = ""
@@ -197,6 +213,50 @@ class TemplatesList(ListCollection):
             assert isinstance(template, Template)
 
 
+def outputs_inputs2templates(inputs: Union[str, List], outputs: Union[str, List]) -> TemplatesList:
+    """
+    combines input and output formats into their dot product
+    :param inputs: list of input formats (or one)
+    :param outputs: list of output formats (or one)
+    :return: TemplatesList of InputOutputTemplate
+    """
+    templates = []
+    if isinstance(inputs, str):
+        inputs = [inputs]
+    if isinstance(outputs, str):
+        outputs = [outputs]
+    for input in inputs:
+        for output in outputs:
+            templates.append(
+                InputOutputTemplate(
+                    input_format=input.strip(),
+                    output_format=output.strip(),
+                ),
+            )
+    return TemplatesList(templates)
+
+
+def instructions2templates(
+    instructions: List[TextualInstruction], templates: List[InputOutputTemplate]
+) -> TemplatesList:
+    """
+    Insert instructions into per demonstration templates
+    :param instructions:
+    :param templates: strings containing {instuction} where the instruction should be placed
+    :return:
+    """
+    res_templates = []
+    for instruction in instructions:
+        for template in templates:
+            res_templates.append(
+                InputOutputTemplate(
+                    input_format=template.input_format.replace("{instruction}", instruction.text),
+                    output_format=template.output_format,
+                )
+            )
+    return TemplatesList(templates)
+
+
 class TemplatesDict(Dict):
     def verify(self):
         for key, template in self.items():