loading script and dataset card

README.md

@@ -0,0 +1,224 @@
+# ludwig---
+annotations_creators:
+- expert-generated
+language:
+- en
+language_creators:
+- expert-generated
+license:
+- cc-by-4.0
+multilinguality:
+- monolingual
+pretty_name: ludwig
+size_categories:
+- n<1K
+source_datasets:
+- original
+tags:
+- implicature
+- pragmatics
+- language
+- llm
+- conversation
+- dialogue
+task_categories:
+- text-generation
+- fill-mask
+task_ids:
+- language-modeling
+- masked-language-modeling
+---
+
+# Dataset Card for LUDWIG
+
+## Table of Contents
+- [Table of Contents](#table-of-contents)
+- [Dataset Description](#dataset-description)
+  - [Dataset Summary](#dataset-summary)
+  - [Supported Tasks and Leaderboards](#supported-tasks-and-leaderboards)
+  - [Languages](#languages)
+- [Dataset Structure](#dataset-structure)
+  - [Data Instances](#data-instances)
+  - [Data Fields](#data-fields)
+  - [Data Splits](#data-splits)
+- [Dataset Creation](#dataset-creation)
+  - [Curation Rationale](#curation-rationale)
+  - [Source Data](#source-data)
+  - [Annotations](#annotations)
+  - [Personal and Sensitive Information](#personal-and-sensitive-information)
+- [Considerations for Using the Data](#considerations-for-using-the-data)
+  - [Social Impact of Dataset](#social-impact-of-dataset)
+  - [Discussion of Biases](#discussion-of-biases)
+  - [Other Known Limitations](#other-known-limitations)
+- [Additional Information](#additional-information)
+  - [Dataset Curators](#dataset-curators)
+  - [Licensing Information](#licensing-information)
+  - [Citation Information](#citation-information)
+  - [Contributions](#contributions)
+
+## Dataset Description
+
+- **Homepage:**
+- **Repository: https://github.com/ucl-dark/ludwig**
+- **Paper: TODO**
+- **Leaderboard: TODO**
+- **Point of Contact: Laura Ruis**
+
+### Dataset Summary
+
+LUDWIG (**L**anguage **U**nderstanding **W**ith **I**mplied meanin**G**) is a dataset containing English conversational implicatures.
+Implicature is the act of meaning or implying one thing by saying something else. 
+There's different types of implicatures, from simple ones like "Some guests came to the party" 
+(implying not all guests came) to more complicated implicatures that depend on context like 
+"A: Are you going to the party this Friday? B: There's a global pandemic.", implying no. Implicatures serve a wide range of
+goals in communication: efficiency, style, navigating social interactions, and more. We cannot fully
+understand utterances without understanding their implications.  
+The implicatures in this dataset  are conversational because they come in utterance-response tuples. 
+Each tuple has an implicature associated with it,
+which is the implied meaning of the response. For example:
+
+Utterance: Are you going to the party this Friday?  
+Response: There's a global pandemic.  
+Implicature: No. 
+
+This dataset can be used to evaluate language models on their pragmatic language understanding.
+
+### Supported Tasks and Leaderboards
+
+- ```text-generation```: The dataset can be used to evaluate a models ability to generate the correct next token, i.e. "yes" or "no", depending on the implicature. For example, if you pass the model an example wrapped in a template like "Esther asked 'Are you coming to the party this Friday' and Juan responded 'There's a global pandemic', which means" the correct completion would be "no". Success in this task can be determined by the ability to generate the correct answer or by the ability to give the right token a higher likelihood than the wrong token, e.g. p("no") > p("yes").
+- ```fill-mask```: The dataset can be used to evaluate a models ability to fill the correct token, i.e. "yes" or "no", depending on the implicature. For example, if you pass the model an example wrapped in a template like "Esther asked 'Are you coming to the party this Friday' and Juan responded 'There's a global pandemic', which means [mask]" the correct mask-fill would be "no". Success in this task can be determined by the ability to fill the correct answer or by the ability to give the right token a higher likelihood than the wrong token, e.g. p("no") > p("yes").
+
+### Languages
+
+English
+
+## Dataset Structure
+
+### Data Instances
+
+Find below an example of a 1-shot example instance (1-shot because there's 1 prompt example).
+```
+{
+  "id": 1,
+  "utterance": "Are you going to the party this Friday?",
+  "response": "There's a global pandemic.",
+  "implicature": "No.",
+  "incoherent_implicature": "Yes".
+  "prompts": [
+      {
+          "utterance": "Was that hot?",
+          "response": "The sun was scorching.",
+          "implicature": "Yes.",
+          "incoherent_implicature": "No.".
+      }
+  ]
+}
+```
+
+### Data Fields
+
+```
+{
+  "id": int,  # unique identifier of data points
+  "utterance": str,  # the utterance in this example
+  "response": str,  # the response in this example
+  "implicature": str,  # the implied meaning of the response, e.g. 'yes'
+  "incoherent_implicature": str,  # the wrong implied meaning, e.g. 'no'
+  "prompts": [  # optional: prompt examples from the validation set
+      {
+          "utterance": str,
+          "response": str,
+          "implicature": str,
+          "incoherent_implicature": str,
+      }
+  ]
+}
+```
+
+### Data Splits
+
+**Validation**: 118 instances that can be used for finetuning or few-shot learning  
+**Test**: 600 instances that can be used for evaluating models.
+
+NB: the splits weren't originally part of the paper that presents this dataset. The same goes for the k-shot prompts. Added
+by @LauraRuis.
+
+## Dataset Creation
+
+### Curation Rationale
+
+Pragmatic language understanding is a crucial aspect of human communication, and implicatures are the primary object of study in this field.
+We want computational models of language to understand all the speakers implications.
+
+### Source Data
+
+#### Initial Data Collection and Normalization
+
+"Conversational implicatures in English dialogue: Annotated dataset", Elizabeth Jasmi George and Radhika Mamidi 2020.
+
+[Link to paper](https://doi.org/10.1016/j.procs.2020.04.251)
+
+#### Who are the source language producers?
+
+These written representations of the utterances are collected manually by scraping and transcribing from relevant sources from August, 2019 to August, 2020. The source of dialogues in the data include TOEFL listening comprehension short conversations, movie dialogues from IMSDb and websites explaining idioms, similes, metaphors and hyperboles. The implicatures are annotated manually.
+
+### Annotations
+
+#### Annotation process
+
+Manually annotated by dataset collectors.
+
+#### Who are the annotators?
+
+Authors of the original paper.
+
+### Personal and Sensitive Information
+
+All the data is public and not sensitive.
+
+## Considerations for Using the Data
+
+### Social Impact of Dataset
+
+Any application that requires communicating with humans requires pragmatic language understanding.
+
+### Discussion of Biases
+
+Implicatures can be biased to specific cultures. For example, whether the Pope is Catholic (a common used response implicature to indicate "yes") might not be common knowledge for everyone.
+Implicatures are also language-specific, the way people use pragmatic language depends on the language. This dataset only focuses on the English language.
+
+### Other Known Limitations
+
+None yet.
+
+## Additional Information
+
+### Dataset Curators
+
+Elizabeth Jasmi George and Radhika Mamidi
+
+### Licensing Information
+
+[license](https://creativecommons.org/licenses/by/4.0/)
+
+### Citation Information
+
+```
+@article{George:Mamidi:2020,
+ author = {George, Elizabeth Jasmi and Mamidi, Radhika},
+ doi = {10.1016/j.procs.2020.04.251},
+ journal = {Procedia Computer Science},
+ keywords = {},
+ note = {https://doi.org/10.1016/j.procs.2020.04.251},
+ number = {},
+ pages = {2316-2323},
+ title = {Conversational implicatures in English dialogue: Annotated dataset},
+ url = {https://app.dimensions.ai/details/publication/pub.1128198497},
+ volume = {171},
+ year = {2020}
+}
+```
+
+### Contributions
+
+Thanks to [@LauraRuis](https://github.com/LauraRuis) for adding this dataset.

ludwig.py

@@ -0,0 +1,255 @@
+# coding=utf-8
+# Copyright 2020 The TensorFlow Datasets Authors and the HuggingFace Datasets Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Lint as: python3
+"""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
+        )
+    ]
+
+    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"),
+                        }
+                    )
+                }
+            ),
+            # No default supervised_keys (as we have to pass both question
+            # and context as input).
+            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,
+            }