Upload templates.py with huggingface_hub

templates.py

@@ -1,6 +1,5 @@
 import json
 from abc import abstractmethod
-from dataclasses import field
 from typing import Any, Dict, List, Optional, Tuple
 
 from .collections import ListCollection
@@ -14,12 +13,21 @@ class Template(StreamInstanceOperator):
     """The role of template is to take the fields of every instance and verbalize it.
 
     Meaning the template is taking the instance and generating source, target and references.
+
+    Args:
+        skip_rendered_instance (bool): if "source", "target", and "references" are already defined fields in the instance, skip its processing
+        postprocessors: a list of strings being artifact names of text processors, to be applied on the model output
+        instruction: a formatting string that yields an instruction with potential participation of values from the "inputs" part of the instance
+        target_prefix: a string to be used to format the prompt. Not a formatting string.
+
     """
 
     skip_rendered_instance: bool = NonPositionalField(default=True)
     postprocessors: List[str] = NonPositionalField(
         default_factory=lambda: ["processors.to_string_stripped"]
     )
+    instruction: str = NonPositionalField(default_factory=lambda: "")
+    target_prefix: str = NonPositionalField(default_factory=lambda: "")
 
     def process(
         self, instance: Dict[str, Any], stream_name: Optional[str] = None
@@ -35,7 +43,7 @@ class Template(StreamInstanceOperator):
         inputs = instance.get("inputs")
         outputs = instance.get("outputs")
 
-        source = self.inputs_to_source(inputs)
+        source, instruction = self.inputs_to_source(inputs)
         target, references = self.outputs_to_target_and_references(outputs)
 
         return {
@@ -43,10 +51,12 @@ class Template(StreamInstanceOperator):
             "source": source,
             "target": target,
             "references": references,
+            "instruction": instruction,
+            "target_prefix": self.target_prefix.format(**inputs),
         }
 
     @abstractmethod
-    def inputs_to_source(self, inputs: Dict[str, object]) -> str:
+    def inputs_to_source(self, inputs: Dict[str, object]) -> Tuple[str, str]:
         pass
 
     @abstractmethod
@@ -72,13 +82,17 @@ class InputOutputTemplate(Template):
         data = {k: ", ".join(v) if isinstance(v, list) else v for k, v in data.items()}
         return template.format(**data)
 
-    def inputs_to_source(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 {list(inputs.keys())} but input format requires a different ones: '{self.input_format}'"
-            ) from e
+    def inputs_to_source(self, inputs: Dict[str, object]) -> Tuple[str, str]:
+        formatted = []
+        for formatting in [self.input_format, self.instruction]:
+            try:
+                formatted.append(self.process_template(formatting, inputs))
+            except KeyError as e:
+                raise KeyError(
+                    f"Available inputs are {list(inputs.keys())} but input format requires a different ones: '{formatting}'"
+                ) from e
+
+        return tuple(formatted)
 
     def outputs_to_target_and_references(self, outputs: Dict[str, object]) -> str:
         try:
@@ -92,6 +106,25 @@ class InputOutputTemplate(Template):
         return target, references
 
 
+class InputOutputReferenceTemplate(InputOutputTemplate):
+    reference: str
+
+    def outputs_to_target_and_references(self, outputs: Dict[str, object]) -> str:
+        output_fields = {}
+        for name, val in [
+            ("target", self.output_format),
+            ("reference", self.reference),
+        ]:
+            try:
+                result = self.process_template(val, outputs)
+                output_fields[name] = result
+            except KeyError as e:
+                raise KeyError(
+                    f"Available outputs are {outputs.keys()} but {name} requires a different one: {val}"
+                ) from e
+        return output_fields["target"], [output_fields["reference"]]
+
+
 class MultipleChoiceTemplate(Template):
     """Formats the input (that specifies the question), the multiple choices to select the answer from, and specifies the field with the correct answer."""
 
@@ -149,19 +182,22 @@ class MultipleChoiceTemplate(Template):
             )
         return enumrated_choices
 
-    def inputs_to_source(self, inputs: Dict[str, object]) -> str:
+    def inputs_to_source(self, inputs: Dict[str, object]) -> Tuple[str, str]:
         choices = self.get_choices(inputs, self.source_choice_format)
         inputs = {
             "numerals": ",".join(self.get_choices(inputs, "{choice_numeral}")),
             **inputs,
             self.choices_field: self.choices_seperator.join(choices),
         }
-        try:
-            return self.input_format.format(**inputs)
-        except KeyError as e:
-            raise KeyError(
-                f"Available inputs are {inputs.keys()} but input format requires a different one: {self.input_format}"
-            ) from e
+        formatted = []
+        for formatting in [self.input_format, self.instruction]:
+            try:
+                formatted.append(formatting.format(**inputs))
+            except KeyError as e:
+                raise KeyError(
+                    f"Available inputs are {inputs.keys()} but input format requires a different one: {formatting}"
+                ) from e
+        return tuple(formatted)
 
     def outputs_to_target_and_references(self, outputs: Dict[str, object]) -> str:
         target = outputs[self.target_field]
@@ -221,20 +257,20 @@ class YesNoTemplate(Template):
     label_field: str = None
     yes_answer: str = "Yes"
     no_answer: str = "No"
-    postprocessors: List[str] = field(
-        default_factory=lambda: ["processors.to_string_stripped"]
-    )
 
-    def inputs_to_source(self, inputs: Dict[str, object]) -> str:
-        try:
-            data = {
-                k: ", ".join(v) if isinstance(v, list) else v for k, v in inputs.items()
-            }
-            return self.input_format.format(**data)
-        except KeyError as e:
-            raise RuntimeError(
-                f"Available inputs are {list(inputs.keys())} but input format requires a different one: {self.input_format}"
-            ) from e
+    def inputs_to_source(self, inputs: Dict[str, object]) -> Tuple[str, str]:
+        data = {
+            k: ", ".join(v) if isinstance(v, list) else v for k, v in inputs.items()
+        }
+        formatted = []
+        for formatting in [self.input_format, self.instruction]:
+            try:
+                formatted.append(formatting.format(**data))
+            except KeyError as e:
+                raise RuntimeError(
+                    f"Available inputs are {list(inputs.keys())} but input format requires a different one: {formatting}"
+                ) from e
+        return tuple(formatted)
 
     def outputs_to_target_and_references(self, outputs: Dict[str, object]) -> str:
         try:
@@ -266,9 +302,6 @@ class YesNoTemplate(Template):
             return self.yes_answer, [self.yes_answer]
         return self.no_answer, [self.no_answer]
 
-    def get_postprocessors(self) -> List[str]:
-        return self.postprocessors
-
 
 class KeyValTemplate(Template):
     """Generate field 'source' from fields designated as input, and fields 'target' and 'references' from fields designated as output, of the processed instance.
@@ -282,10 +315,6 @@ class KeyValTemplate(Template):
     outputs_key_val_seperator: str = ": "
     use_keys_for_outputs: bool = False
 
-    postprocessors: List[str] = field(
-        default_factory=lambda: ["processors.to_string_stripped"]
-    )
-
     def process_dict(
         self, dic: Dict[str, object], key_val_sep, pairs_sep, use_keys
     ) -> str:
@@ -299,13 +328,14 @@ class KeyValTemplate(Template):
             pairs.append(key_val_sep.join(key_val))
         return pairs_sep.join(pairs)
 
-    def inputs_to_source(self, inputs: Dict[str, object]) -> str:
-        return self.process_dict(
+    def inputs_to_source(self, inputs: Dict[str, object]) -> Tuple[str, str]:
+        ret = self.process_dict(
             inputs,
             key_val_sep=self.key_val_seperator,
             pairs_sep=self.pairs_seperator,
             use_keys=self.use_keys_for_inputs,
         )
+        return (ret, ret)
 
     def outputs_to_target_and_references(self, outputs: Dict[str, object]) -> str:
         target = self.process_dict(
@@ -316,9 +346,6 @@ class KeyValTemplate(Template):
         )
         return target, [target]
 
-    def get_postprocessors(self) -> List[str]:
-        return self.postprocessors
-
 
 class OutputQuantizingTemplate(InputOutputTemplate):
     quantum: float = 0.1