| import json |
| from abc import abstractmethod |
| from typing import Any, Dict, List, Optional, Tuple |
|
|
| from .collections import ListCollection |
| from .dataclass import NonPositionalField |
| from .operator import StreamInstanceOperator |
| from .random_utils import new_random_generator |
| from .type_utils import isoftype |
|
|
|
|
| class TemplateFormatKeyError(KeyError): |
| def __init__(self, template, data, data_type, format_str, format_name): |
| keys = ", ".join(data.keys()) |
| super().__init__( |
| f"Available {data_type}s are [{keys}] " |
| f"but {template.__class__.__name__}.{format_name} format requires a different ones: '{format_str}'" |
| ) |
|
|
|
|
| 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="") |
| target_prefix: str = NonPositionalField(default="") |
| title_fields: List[str] = NonPositionalField(default_factory=list) |
|
|
| def inputs_to_instruction_and_target_prefix(self, inputs): |
| instruction = self.apply_formatting( |
| inputs, "input", self.instruction, "instruction", serialize=True |
| ) |
| target_prefix = self.apply_formatting( |
| inputs, "input", self.target_prefix, "target_prefix", serialize=True |
| ) |
| return instruction, target_prefix |
|
|
| def process( |
| self, instance: Dict[str, Any], stream_name: Optional[str] = None |
| ) -> Dict[str, Any]: |
| if self.skip_rendered_instance: |
| if ( |
| "source" in instance |
| and "target" in instance |
| and "references" in instance |
| ): |
| return instance |
|
|
| inputs = instance.get("inputs") |
| outputs = instance.get("outputs") |
|
|
| self.set_titles(inputs) |
|
|
| source = self.inputs_to_source(inputs) |
| instruction, target_prefix = self.inputs_to_instruction_and_target_prefix( |
| inputs |
| ) |
| target, references = self.outputs_to_target_and_references(outputs) |
|
|
| return { |
| **instance, |
| "source": source, |
| "target": target, |
| "references": references, |
| "instruction": instruction, |
| "target_prefix": target_prefix, |
| } |
|
|
| @abstractmethod |
| def inputs_to_source(self, inputs: Dict[str, object]) -> Tuple[str, str]: |
| pass |
|
|
| def set_titles(self, data): |
| for field in self.title_fields: |
| data[field] = data[field].title() |
|
|
| @abstractmethod |
| def outputs_to_target_and_references( |
| self, outputs: Dict[str, object] |
| ) -> Tuple[str, List[str]]: |
| pass |
|
|
| def get_postprocessors(self) -> List[str]: |
| return self.postprocessors |
|
|
| def serialize_data(self, data): |
| return { |
| k: ", ".join(str(t) for t in v) if isinstance(v, list) else v |
| for k, v in data.items() |
| } |
|
|
| def apply_formatting( |
| self, data, data_type, format_str, format_name, serialize=False |
| ) -> str: |
| if serialize: |
| data = self.serialize_data(data) |
| try: |
| return format_str.format(**data) |
| except KeyError as e: |
| raise TemplateFormatKeyError( |
| self, data, data_type, format_str, format_name |
| ) from e |
|
|
|
|
| class InputOutputTemplate(Template): |
| """Generate field 'source' from fields designated as input, and fields 'target' and 'references' from fields designated as output, of the processed instance. |
| |
| Args specify the formatting strings with which to glue together the input and output designated fields of the processed instance into one string ('source' and 'target'), and into a list of strings ('references'). |
| """ |
|
|
| input_format: str = None |
| output_format: str = None |
|
|
| def inputs_to_source(self, inputs: Dict[str, object]) -> Tuple[str, str]: |
| return self.apply_formatting( |
| inputs, "input", self.input_format, "input_format", serialize=True |
| ) |
|
|
| def outputs_to_target_and_references(self, outputs: Dict[str, object]) -> str: |
| target = self.apply_formatting( |
| outputs, "output", self.output_format, "output_format", serialize=True |
| ) |
| references = [target] |
| return target, references |
|
|
|
|
| class InputOutputReferenceTemplate(InputOutputTemplate): |
| reference: str |
|
|
| def outputs_to_target_and_references(self, outputs: Dict[str, object]) -> str: |
| target = self.apply_formatting( |
| outputs, "output", self.output_format, "output_format", serialize=True |
| ) |
| reference = self.apply_formatting( |
| outputs, "output", self.reference, "reference", serialize=True |
| ) |
| return target, [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.""" |
|
|
| input_format: str |
| target_prefix: str = "" |
| choices_field: str = "choices" |
| target_field: str = "label" |
| choices_seperator: str = ", " |
| source_choice_format: str = "{choice_numeral}. {choice_text}" |
| target_choice_format: str = "{choice_numeral}" |
| enumerator: str = "capitals" |
|
|
| def prepare(self): |
| super().prepare() |
| if self.enumerator == "capitals": |
| self.enumerator = "ABCDEFGHIJKLMNOP" |
| if self.enumerator == "lowercase": |
| self.enumerator = "abcdefghijklmnop" |
| if self.enumerator == "numbers": |
| self.enumerator = [str(i + 1) for i in range(20)] |
| if self.enumerator == "roman": |
| self.enumerator = [ |
| "I", |
| "II", |
| "III", |
| "IV", |
| "V", |
| "VI", |
| "VII", |
| "VIII", |
| "IX", |
| "X", |
| "XI", |
| "XII", |
| "XIII", |
| "XIV", |
| "XV", |
| "XVI", |
| "XVII", |
| "XVIII", |
| "XIX", |
| "XX", |
| ] |
|
|
| def inputs_to_choices(self, data: Dict[str, object], choice_format: str) -> str: |
| choices = data[self.choices_field] |
| enumrated_choices = [] |
| for i, choice in enumerate(choices): |
| enumrated_choices.append( |
| choice_format.format( |
| choice_text=choice, |
| choice_numeral=self.enumerator[i], |
| ) |
| ) |
| return enumrated_choices |
|
|
| def inputs_to_numerals(self, inputs: Dict[str, object]) -> Tuple[str, str]: |
| return self.inputs_to_choices(inputs, "{choice_numeral}") |
|
|
| def prepare_multiple_choice_inputs( |
| self, inputs: Dict[str, object] |
| ) -> Dict[str, object]: |
| choices = self.inputs_to_choices(inputs, self.source_choice_format) |
| return { |
| "numerals": self.inputs_to_numerals(inputs), |
| **inputs, |
| self.choices_field: self.choices_seperator.join(choices), |
| } |
|
|
| def inputs_to_source(self, inputs: Dict[str, object]) -> Tuple[str, str]: |
| inputs = self.prepare_multiple_choice_inputs(inputs) |
| return self.apply_formatting( |
| inputs, "input", self.input_format, "input_format", serialize=True |
| ) |
|
|
| def inputs_to_instruction_and_target_prefix(self, inputs): |
| inputs = self.prepare_multiple_choice_inputs(inputs) |
| return super().inputs_to_instruction_and_target_prefix(inputs) |
|
|
| def outputs_to_target_and_references(self, outputs: Dict[str, object]) -> str: |
| target = outputs[self.target_field] |
|
|
| if not isinstance(target, int): |
| try: |
| target = outputs[self.choices_field].index(target) |
| except ValueError as e: |
| raise ValueError( |
| f"MultipleChoiceTemplate could not locate textual target '{target}' in choices list: {outputs[self.choices_field]}" |
| ) from e |
|
|
| choices = self.inputs_to_choices(outputs, self.target_choice_format) |
|
|
| try: |
| target = choices[target] |
| except IndexError as e: |
| raise IndexError( |
| f"MultipleChoiceTemplate cannot find index number {target} in choices: {choices}" |
| ) from e |
|
|
| return target, [target] |
|
|
| def process( |
| self, instance: Dict[str, Any], stream_name: Optional[str] = None |
| ) -> Dict[str, Any]: |
| result = super().process(instance, stream_name) |
| if "options" not in result["outputs"]: |
| result["outputs"]["options"] = self.inputs_to_choices( |
| instance["outputs"], self.target_choice_format |
| ) |
| return result |
|
|
|
|
| class YesNoTemplate(Template): |
| """A template for generating binary Yes/No questions asking whether an input text is of a specific class. |
| |
| input_format: |
| Defines the format of the question. |
| class_field: |
| Defines the field that contains the name of the class that this template |
| asks of. |
| label_field: |
| Defines the field which contains the true label of the input text. If a gold label is equal to the |
| value in class_name, then the correct output is self.yes_answer (by default, "Yes"). |
| Otherwise the correct output is self.no_answer (by default, "No"). |
| yes_answer: |
| The output value for when the gold label equals self.class_name. |
| Defaults to "Yes". |
| no_answer: |
| The output value for when the gold label differs from self.class_name. |
| Defaults to "No". |
| """ |
|
|
| input_format: str = None |
| class_field: str = None |
| label_field: str = None |
| yes_answer: str = "Yes" |
| no_answer: str = "No" |
|
|
| def inputs_to_source(self, inputs: Dict[str, object]) -> Tuple[str, str]: |
| return self.apply_formatting( |
| inputs, "input", self.input_format, "input_format", serialize=True |
| ) |
|
|
| def outputs_to_target_and_references(self, outputs: Dict[str, object]) -> str: |
| try: |
| gold_class_names = outputs[self.label_field] |
| except KeyError as e: |
| raise RuntimeError( |
| f"Available outputs are {list(outputs.keys())}, missing required label field: '{self.label_field}'." |
| ) from e |
| if not isinstance(gold_class_names, list) or not gold_class_names: |
| raise RuntimeError( |
| f"Unexpected value for gold_class_names: '{gold_class_names}'. Expected a non-empty list." |
| ) |
| try: |
| queried_class_names = outputs[self.class_field] |
| except KeyError as e: |
| raise RuntimeError( |
| f"Available outputs are {list(outputs.keys())}, missing required class field: '{self.class_field}'." |
| ) from e |
| if ( |
| not queried_class_names |
| or not isinstance(queried_class_names, list) |
| or not len(queried_class_names) == 1 |
| ): |
| raise RuntimeError( |
| f"Unexpected value for queried_class_names: '{queried_class_names}'. Expected a list with one item." |
| ) |
| queried_class_name = queried_class_names[0] |
| if queried_class_name in gold_class_names: |
| return self.yes_answer, [self.yes_answer] |
| return self.no_answer, [self.no_answer] |
|
|
|
|
| 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. |
| |
| Args specify with what separators to glue together the input and output designated fields of the processed instance into one string ('source' and 'target'), and into a list of strings ('references'). |
| """ |
|
|
| pairs_seperator: str = ", " |
| key_val_seperator: str = ": " |
| use_keys_for_inputs: bool = True |
| outputs_key_val_seperator: str = ": " |
| use_keys_for_outputs: bool = False |
|
|
| def process_dict( |
| self, data: Dict[str, object], key_val_sep, pairs_sep, use_keys |
| ) -> str: |
| data = self.serialize_data(data) |
| pairs = [] |
| for key, val in data.items(): |
| key_val = [key, str(val)] if use_keys else [str(val)] |
| pairs.append(key_val_sep.join(key_val)) |
| return pairs_sep.join(pairs) |
|
|
| def inputs_to_source(self, inputs: Dict[str, object]) -> Tuple[str, str]: |
| return self.process_dict( |
| inputs, |
| key_val_sep=self.key_val_seperator, |
| pairs_sep=self.pairs_seperator, |
| use_keys=self.use_keys_for_inputs, |
| ) |
|
|
| def outputs_to_target_and_references(self, outputs: Dict[str, object]) -> str: |
| target = self.process_dict( |
| outputs, |
| key_val_sep=self.key_val_seperator, |
| pairs_sep=self.pairs_seperator, |
| use_keys=self.use_keys_for_outputs, |
| ) |
| return target, [target] |
|
|
|
|
| class OutputQuantizingTemplate(InputOutputTemplate): |
| quantum: float = 0.1 |
|
|
| def outputs_to_target_and_references(self, outputs: Dict[str, object]) -> str: |
| quantum_str = f"{self.quantum:.10f}".rstrip("0").rstrip(".") |
| quantized_outputs = { |
| key: f"{round(value / self.quantum) * self.quantum:{quantum_str}}" |
| for key, value in outputs.items() |
| } |
| return super().outputs_to_target_and_references(quantized_outputs) |
|
|
|
|
| class MultiLabelTemplate(InputOutputTemplate): |
| labels_field: str = "labels" |
| labels_seprator: str = ", " |
| postprocessors: List[str] = ["processors.to_list_by_comma"] |
| output_format: str = "{labels}" |
| empty_label: str = "None" |
|
|
| def outputs_to_target_and_references(self, outputs: Dict[str, object]) -> str: |
| labels = outputs[self.labels_field] |
| if not isinstance(labels, list): |
| raise ValueError( |
| f"MultiLabelTemplate requires labels field '{self.labels_field}' to be a list. Got {self.labels_field}<{type(labels).__name__}>: {labels}" |
| ) |
| if len(labels) == 0: |
| labels = [self.empty_label] |
| labels_str = self.labels_seprator.join(labels) |
| return super().outputs_to_target_and_references({self.labels_field: labels_str}) |
|
|
|
|
| class MultiReferenceTemplate(InputOutputTemplate): |
| references_field: str = "references" |
| random_reference: bool = False |
|
|
| def outputs_to_target_and_references(self, outputs: Dict[str, object]) -> List[str]: |
| references = outputs[self.references_field] |
| if not isoftype(references, List[str]): |
| raise ValueError( |
| f"MultiReferenceTemplate requires references field '{self.references_field}' to be List[str]. Got {self.references_field}<{type(references).__name__}>: {references}" |
| ) |
| if len(references) == 0: |
| raise ValueError( |
| "No references found. MultiReferenceTemplate requires at least one reference." |
| ) |
|
|
| if self.random_reference: |
| random_generator = new_random_generator(outputs) |
| target = random_generator.choice(references) |
| else: |
| target = references[0] |
|
|
| return target, references |
|
|
|
|
| def escape_chars(s, chars_to_escape): |
| for char in chars_to_escape: |
| s = s.replace(char, f"\\{char}") |
| return s |
|
|
|
|
| class SpanLabelingBaseTemplate(MultiLabelTemplate): |
| spans_starts_field: str = "spans_starts" |
| spans_ends_field: str = "spans_ends" |
| text_field: str = "text" |
| labels_support: list = None |
|
|
| def extract_span_label_pairs(self, outputs): |
| spans_starts = outputs[self.spans_starts_field] |
| spans_ends = outputs[self.spans_ends_field] |
| text = outputs[self.text_field] |
| labels = outputs[self.labels_field] |
|
|
| spans = [] |
| for span_start, span_end, label in zip(spans_starts, spans_ends, labels): |
| if self.labels_support is None or label in self.labels_support: |
| spans.append((span_start, span_end, text[span_start:span_end], label)) |
|
|
| for span in sorted(spans): |
| if self.labels_support is None or span[3] in self.labels_support: |
| yield span[2], span[3] |
|
|
| def outputs_to_target_and_references( |
| self, outputs: Dict[str, object] |
| ) -> Dict[str, object]: |
| span_lables_pairs = self.extract_span_label_pairs(outputs) |
| targets = self.span_label_pairs_to_targets(span_lables_pairs) |
| return super().outputs_to_target_and_references({"labels": targets}) |
|
|
| @abstractmethod |
| def span_label_pairs_to_targets(self, pairs): |
| pass |
|
|
|
|
| class SpanLabelingTemplate(SpanLabelingBaseTemplate): |
| span_label_format: str = "{span}: {label}" |
| escape_characters: List[str] = [":", ","] |
| postprocessors: List[str] = ["processors.to_span_label_pairs"] |
|
|
| def span_label_pairs_to_targets(self, span_label_pairs): |
| targets = [] |
| for span, label in span_label_pairs: |
| if self.escape_characters is not None: |
| span = escape_chars(span, self.escape_characters) |
| target = self.span_label_format.format(span=span, label=label) |
| targets.append(target) |
| return targets |
|
|
|
|
| class SpanLabelingJsonTemplate(SpanLabelingBaseTemplate): |
| postprocessors = [ |
| "processors.load_json", |
| "processors.dict_of_lists_to_value_key_pairs", |
| ] |
|
|
| def span_label_pairs_to_targets(self, span_label_pairs): |
| groups = {} |
| for span, label in span_label_pairs: |
| if label not in groups: |
| groups[label] = [] |
| groups[label].append(span) |
| if len(groups) > 0: |
| targets = [json.dumps(groups, ensure_ascii=False)] |
| else: |
| targets = [] |
| return targets |
|
|
|
|
| class TemplatesList(ListCollection): |
| def verify(self): |
| for template in self.items: |
| assert isinstance(template, Template) |
|
|
|
|
| class TemplatesDict(Dict): |
| def verify(self): |
| for _key, template in self.items(): |
| assert isinstance(template, Template) |
|
|
