| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| |
| """LUDWIG, (Language Understanding With Implied meaninG). The conversational implicature dataset.""" |
|
|
|
|
| from typing import Dict, Union |
| import numpy as np |
| import copy |
| import csv |
| import os |
|
|
| import datasets |
|
|
|
|
| logger = datasets.logging.get_logger(__name__) |
|
|
|
|
| _CITATION = """\ |
| TBC |
| """ |
|
|
| _DESCRIPTION = """\ |
| TODO |
| """ |
|
|
| _URL = "https://raw.githubusercontent.com/ucl-dark/ludwig/main/" |
| _URLS = { |
| "dev": _URL + "dev_conversational_implicatures.csv", |
| "test": _URL + "test_conversational_implicatures.csv" |
| } |
|
|
|
|
| class LudwigConfig(datasets.BuilderConfig): |
| """BuilderConfig for LUDWIG.""" |
|
|
| def __init__(self, k: int, seed: int, **kwargs): |
| """BuilderConfig for LUDWIG. |
| Args: |
| **kwargs: keyword arguments forwarded to super. |
| """ |
| super(LudwigConfig, self).__init__(**kwargs) |
| self.k = k |
| self.seed = seed |
| self.rng = np.random.default_rng(seed) |
|
|
| def __eq__(self, other): |
| return self.k == other.k and self.seed == other.seed |
|
|
| def reset_rng(self): |
| self.rng = np.random.default_rng(self.seed) |
|
|
|
|
| class Ludwig(datasets.GeneratorBasedBuilder): |
| """LUDWIG: Conversational implicatures dataset.""" |
|
|
| BUILDER_CONFIGS = [ |
| LudwigConfig( |
| name="0-shot", |
| version=datasets.Version("1.0.0", ""), |
| description="Plain text", |
| k=0, |
| seed=0, |
| ), |
| LudwigConfig( |
| name="1-shot", |
| version=datasets.Version("1.0.0", ""), |
| description="Plain text", |
| k=1, |
| seed=0 |
| ), |
| LudwigConfig( |
| name="5-shot", |
| version=datasets.Version("1.0.0", ""), |
| description="Plain text", |
| k=5, |
| seed=0 |
| ), |
| LudwigConfig( |
| name="10-shot", |
| version=datasets.Version("1.0.0", ""), |
| description="Plain text", |
| k=10, |
| seed=0 |
| ), |
| LudwigConfig( |
| name="15-shot", |
| version=datasets.Version("1.0.0", ""), |
| description="Plain text", |
| k=15, |
| seed=0 |
| ), |
| LudwigConfig( |
| name="30-shot", |
| version=datasets.Version("1.0.0", ""), |
| description="Plain text", |
| k=30, |
| seed=0 |
| ) |
| ] |
|
|
| def _info(self): |
| return datasets.DatasetInfo( |
| description=_DESCRIPTION, |
| features=datasets.Features( |
| { |
| "id": datasets.Value("string"), |
| "utterance": datasets.Value("string"), |
| "response": datasets.Value("string"), |
| "implicature": datasets.Value("string"), |
| "incoherent_implicature": datasets.Value("string"), |
| "prompts": datasets.features.Sequence( |
| { |
| "utterance": datasets.Value("string"), |
| "response": datasets.Value("string"), |
| "implicature": datasets.Value("string"), |
| "incoherent_implicature": datasets.Value("string"), |
| } |
| ) |
| } |
| ), |
| |
| |
| supervised_keys=None, |
| homepage="https://github.com/ucl-dark/ludwig", |
| citation=_CITATION |
| ) |
|
|
| def _split_generators(self, dl_manager): |
| downloaded_files = dl_manager.download_and_extract(_URLS) |
|
|
| return [ |
| datasets.SplitGenerator(name=datasets.Split.VALIDATION, gen_kwargs={"filepath": downloaded_files["dev"], |
| "dev_filepath": downloaded_files["dev"], |
| "k": self.config.k}), |
| datasets.SplitGenerator(name=datasets.Split.TEST, gen_kwargs={"filepath": downloaded_files["test"], |
| "dev_filepath": downloaded_files["dev"], |
| "k": self.config.k}), |
| ] |
|
|
| @staticmethod |
| def _process_text(text): |
| return text.strip("\n") |
|
|
| def _filter_examples( |
| self, input_line: Dict[str, str], |
| ) -> Union[None, Dict[str, str]]: |
| """ |
| Takes an input_line from the csv file and filters all examples |
| where the implicature is not a simple yes or no. |
| :param input_line: a line read from a csv file with data |
| :param source: the source of the example |
| :return: |
| """ |
| if not input_line: |
| return None |
| if "yes" in input_line["Implicature"].lower()[:5]: |
| implicature = "yes" |
| elif "no" in input_line["Implicature"].lower()[:4]: |
| implicature = "no" |
| else: |
| return None |
| response = self._process_text(input_line["Response utterance"]) |
| example = { |
| "utterance": self._process_text(input_line["Context utterance"]), |
| "response": response, |
| "implicature": implicature, |
| } |
| return example |
|
|
| def get_negative_binary_example(self, example): |
| """ |
| Creates a false example for a binary implicature example. |
| :param example: |
| :return: the same dict as the input except for the implicature is negated (yes to no and vice-versa) |
| """ |
| if example["implicature"] == "yes": |
| false_implicature = "no" |
| elif example["implicature"] == "no": |
| false_implicature = "yes" |
| else: |
| raise ValueError("Unknown implicature %s" % example["implicature"]) |
| false_example = copy.deepcopy(example) |
| false_example["implicature"] = false_implicature |
| return false_example |
|
|
| def read_data_csv( |
| self, |
| test_input_data_path: str, |
| dev_input_data_path: str, |
| ): |
| assert os.path.exists( |
| test_input_data_path |
| ), "No input data file found at: %s\n" "Current working direction: %s" % ( |
| test_input_data_path, |
| os.getcwd(), |
| ) |
| assert os.path.exists( |
| dev_input_data_path |
| ), "No dev input data file found at: %s\n" "Current working direction: %s" % ( |
| dev_input_data_path, |
| os.getcwd(), |
| ) |
| with open(test_input_data_path, newline="") as csvfile: |
| with open(dev_input_data_path, newline="") as dev_csvfile: |
| reader = csv.DictReader(csvfile) |
| dev_reader = csv.DictReader(dev_csvfile) |
| all_data = { |
| "test_data": [], |
| "dev_data": [], |
| } |
| for row in reader: |
| example = self._filter_examples(row) |
| if example is not None: |
| negative_example = self.get_negative_binary_example(example)["implicature"] |
| example = {**example, |
| "incoherent_implicature": negative_example} |
| all_data["test_data"].append(example) |
| for row in dev_reader: |
| example = self._filter_examples(row) |
| if example is not None: |
| negative_example = self.get_negative_binary_example(example)["implicature"] |
| example = {**example, |
| "incoherent_implicature": negative_example} |
| all_data["dev_data"].append(example) |
| return all_data |
|
|
| def _get_prompt_examples(self, dev_data, k_shot=0): |
| """ |
| A function to parse the i-th example in self.data["data"] |
| :param dev_data: list of examples to sample from |
| :param k_shot: how many extra examples to parse from different indices than i |
| :return: a parsed example |
| """ |
| if k_shot > 0: |
| prompt_indices = self.config.rng.choice( |
| range(len(dev_data)), k_shot, replace=False |
| ) |
| prompt_examples = [dev_data[j] for j in prompt_indices] |
| else: |
| prompt_examples = [] |
| return prompt_examples |
|
|
| def _generate_examples(self, filepath, dev_filepath, k: int): |
| """This function returns the examples in the raw (text) form.""" |
| logger.info("generating examples from = %s", filepath) |
| logger.info("k-shot examples from = %s", dev_filepath) |
| all_data = self.read_data_csv(filepath, dev_filepath) |
| self.config.reset_rng() |
| for i, example in enumerate(all_data["test_data"]): |
| prompt_examples = self._get_prompt_examples(all_data["dev_data"], k) |
| yield i, { |
| **example, |
| "prompts": prompt_examples, |
| "id": i + 1, |
| } |
|
|
