Load from reformatted data (jsonl, at qasrl.org) by default - aligned question slots with qasrl-2018 data

qanom.py

@@ -20,7 +20,9 @@ from typing import Optional, Tuple
 import datasets
 from pathlib import Path
 import pandas as pd
-
+import gzip
+import json
+import itertools
 
 _CITATION = """\
 @inproceedings{klein2020qanom,
@@ -68,7 +70,8 @@ SOFTWARE."""
 
 
 _URLs = {
-    "qanom_zip":  "https://github.com/kleinay/QANom/raw/master/qanom_dataset.zip"
+    "qanom_csv":  "https://github.com/kleinay/QANom/raw/master/qanom_dataset.zip",
+    "qanom_jsonl":  "https://qasrl.org/data/qanom.tar"
 }
 
 SpanFeatureType = datasets.Sequence(datasets.Value("int32"), length=2)
@@ -78,7 +81,7 @@ class QANomBuilderConfig(datasets.BuilderConfig):
     """ Allow the loader to re-distribute the original dev and test splits between train, dev and test. """
     redistribute_dev: Tuple[float, float, float] = (0., 1., 0.)
     redistribute_test: Tuple[float, float, float] = (0., 0., 1.)
-    
+    load_from: str = "jsonl" # "csv" or "jsonl"
     
 
 # TODO: Name of the dataset usually match the script name with CamelCase instead of snake_case
@@ -90,7 +93,7 @@ class Qanom(datasets.GeneratorBasedBuilder):
     are for canidate nominalization which are judged to be non-predicates ("is_verbal"==False) or predicates with no QAs.
     In these cases, the qa fields (question, answers, answer_ranges) would be empty lists. """
 
-    VERSION = datasets.Version("1.0.2")
+    VERSION = datasets.Version("1.1.0")
     
     BUILDER_CONFIG_CLASS = QANomBuilderConfig
 
@@ -149,16 +152,25 @@ class Qanom(datasets.GeneratorBasedBuilder):
                 
     def _split_generators(self, dl_manager: datasets.utils.download_manager.DownloadManager):
         """Returns SplitGenerators."""            
-        # prepare wiktionary for verb inflections inside 'self.verb_inflections'
-        self._prepare_wiktionary_verb_inflections(dl_manager)
+         
+        assert self.config.load_from in ("csv", "jsonl")
         
-        self.corpus_base_path = Path(dl_manager.download_and_extract(_URLs["qanom_zip"]))        
-        
-        self.dataset_files = [
-            self.corpus_base_path / "annot.train.csv",
-            self.corpus_base_path / "annot.dev.csv",
-            self.corpus_base_path / "annot.test.csv"
-        ]
+        self.corpus_base_path = Path(dl_manager.download_and_extract(_URLs[f"qanom_{self.config.load_from}"]))        
+        if self.config.load_from == "csv":
+            # prepare wiktionary for verb inflections inside 'self.verb_inflections'
+            self._prepare_wiktionary_verb_inflections(dl_manager)
+            self.dataset_files = [
+                self.corpus_base_path / "annot.train.csv",
+                self.corpus_base_path / "annot.dev.csv",
+                self.corpus_base_path / "annot.test.csv"
+            ]
+        elif self.config.load_from == "jsonl":
+            self.dataset_files = [
+                self.corpus_base_path / "qanom" / "train.jsonl.gz",
+                self.corpus_base_path / "qanom" / "dev.jsonl.gz",
+                self.corpus_base_path / "qanom" / "test.jsonl.gz"
+            ]
+             
         
         # proportional segment (start,end) to take from every original split to returned SplitGenerator 
         orig_dev_segments = ((0, self.config.redistribute_dev[0]),
@@ -201,12 +213,93 @@ class Qanom(datasets.GeneratorBasedBuilder):
             ),
         ]
 
+    def _generate_examples(self, split_proportion):
+        if self.config.load_from == "csv":
+            return self._generate_examples_from_csv(split_proportion=split_proportion)
+        elif self.config.load_from == "jsonl": 
+            return self._generate_examples_from_jsonl(split_proportion=split_proportion)
+    
+    def _generate_examples_from_jsonl(self, split_proportion):
+        """ Yields examples from a jsonl.gz file, in same format as qasrl-v2."""
+        empty_to_underscore = lambda s: "_" if s=="" else s
+        def read_lines(filepath):
+            with gzip.open(filepath, "rt") as f:
+                return [line.strip() for line in f]
+            
+        
+        orig_splits_jsons = [read_lines(filepath)
+                           for filepath in self.dataset_files]  # train, dev, test
+        # Each json-line stands for a sentence with several predicates and QAs; we will redistribute  
+        #  the new proportions of the splits on the sentence level for convenience 
+        lines_from_orig_splits = [jsonlines[int(len(jsonlines)*start) : int(len(jsonlines)*end)] 
+                                  for jsonlines, (start,end) in zip(orig_splits_jsons, split_proportion)] 
+        this_split_lines = list(itertools.chain(*lines_from_orig_splits))
+        qa_counter = 0
+        for line in this_split_lines:
+            sent_obj = json.loads(line.strip())
+            tokens = sent_obj['sentenceTokens']
+            sentence = ' '.join(tokens)
+            for predicate_idx, verb_obj in sent_obj['verbEntries'].items():
+                verb_forms = verb_obj['verbInflectedForms']
+                predicate = tokens[int(predicate_idx)]
+                for question_obj in verb_obj['questionLabels'].values():
+                    question_slots = question_obj['questionSlots']
+                    verb_form = question_slots['verb'] 
+                    verb_surface = verb_forms[verb_form.split(" ")[-1]] # if verb_form in verb_forms else verb_forms['stem']
+                    question_slots_in_order = [
+                        question_slots["wh"],
+                        question_slots["aux"],
+                        question_slots["subj"],                            
+                        verb_surface,
+                        question_slots["obj"],
+                        empty_to_underscore(question_slots["prep"]), # fix bug in data
+                        question_slots["obj2"],
+                        '?'
+                    ] 
+                    # retrieve answers
+                    answer_spans = []
+                    for ans in question_obj['answerJudgments']:
+                        if ans['isValid']: 
+                            answer_spans.extend(ans['spans']) 
+                    answer_spans = list(set(tuple(a) for a in answer_spans))
+                    # answer_spans = list(set(answer_spans))
+                    answer_strs = [' '.join([tokens[i] for i in range(*span)])
+                                for span in answer_spans]
+                    
+                    yield qa_counter, {
+                        "sentence": sentence,
+                        "sent_id": sent_obj['sentenceId'],
+                        "predicate_idx": predicate_idx,
+                        "predicate": predicate,
+                        "is_verbal": True,
+                        "verb_form": verb_forms['stem'],
+                        "question": question_slots_in_order,
+                        "answers": answer_strs,
+                        "answer_ranges": answer_spans
+                    }
+                    qa_counter += 1
+            # also return non-predicates with empty data
+            for non_predicate_idx, non_predicate in sent_obj["nonPredicates"].items():
+                yield qa_counter, {
+                    "sentence": sentence,
+                    "sent_id": sent_obj['sentenceId'],
+                    "predicate_idx": int(non_predicate_idx),
+                    "predicate": non_predicate,
+                    "is_verbal": False,
+                    "verb_form": "",
+                    "question": [],
+                    "answers": [],
+                    "answer_ranges": []
+                }
+                qa_counter += 1
+                
+        
     @classmethod
     def span_from_str(cls, s:str):
         start, end = s.split(":")
         return [int(start), int(end)]
     
-    def _generate_examples(self, split_proportion=None):
+    def _generate_examples_from_csv(self, split_proportion):
 
         """ Yields examples from a 'annot.?.csv' file in QANom's format."""