Add paragraph-level aggregation

README.md

@@ -41,7 +41,12 @@ document available at https://www.clarin.si/repository/xmlui/bitstream/handle/11
 
 By default the dataset is provided at **sentence-level** (125867 instances): each instance contains a source (the original) and a target (the corrected) sentence. Note that either the source or the target sentence in an instance may be missing - this usually happens when a source sentence is marked as redundant or when a new sentence is added by the teacher. Additionally, a source or a target sentence may appear in multiple instances - for example, this happens when one sentence gets divided into multiple sentences.
 
-There is also an option to aggregate the instances at the **document-level** by explicitly providing the correct config: `datasets.load_dataset("cjvt/solar3", "document_level")`.  
+There is also an option to aggregate the instances at the **document-level** or **paragraph-level** 
+by explicitly providing the correct config:  
+```
+datasets.load_dataset("cjvt/solar3", "paragraph_level")`
+datasets.load_dataset("cjvt/solar3", "document_level")`  
+```
 
 ### Supported Tasks and Leaderboards
 

solar3.py

@@ -126,6 +126,7 @@ def read_data(data_path):
                 data[id_sent] = {
                     "id_doc": id_text,
                     "doc_title": text_title,
+                    "idx_par": idx_par,
                     "id_token": ids, "form": forms, "lemma": lemmas, "ana": msds_jos, "msd": msds_ud, "ne_tag": nes, "space_after": spaces_after,
                     "is_manually_validated": is_manually_validated
                 }
@@ -142,6 +143,8 @@ class Solar3(datasets.GeneratorBasedBuilder):
     BUILDER_CONFIGS = [
         datasets.BuilderConfig(name="sentence_level", version=VERSION,
                                description="Annotations at sentence-level."),
+        datasets.BuilderConfig(name="paragraph_level", version=VERSION,
+                               description="Annotations at paragraph-level."),
         datasets.BuilderConfig(name="document_level", version=VERSION,
                                description="Annotations at document-level."),
     ]
@@ -225,10 +228,14 @@ class Solar3(datasets.GeneratorBasedBuilder):
 
             if len(involved_src_sents) > 0:
                 src_sent_data = deepcopy(source_data[involved_src_sents[0]])
+                if not isinstance(src_sent_data["idx_par"], list):
+                    src_sent_data["idx_par"] = [src_sent_data["idx_par"]]
 
                 for src_sent_id in involved_src_sents[1:]:
                     curr_sent_data = source_data[src_sent_id]
+
                     src_sent_data["id_token"].extend(curr_sent_data["id_token"])
+                    src_sent_data["idx_par"].append(curr_sent_data["idx_par"])
                     src_sent_data["form"].extend(curr_sent_data["form"])
                     src_sent_data["lemma"].extend(curr_sent_data["lemma"])
                     src_sent_data["ana"].extend(curr_sent_data["ana"])
@@ -244,10 +251,14 @@ class Solar3(datasets.GeneratorBasedBuilder):
 
             if len(involved_tgt_sents) > 0:
                 tgt_sent_data = deepcopy(target_data[involved_tgt_sents[0]])
+                if not isinstance(tgt_sent_data["idx_par"], list):
+                    tgt_sent_data["idx_par"] = [tgt_sent_data["idx_par"]]
 
                 for tgt_sent_id in involved_tgt_sents[1:]:
                     curr_sent_data = target_data[tgt_sent_id]
+
                     tgt_sent_data["id_token"].extend(curr_sent_data["id_token"])
+                    tgt_sent_data["idx_par"].append(curr_sent_data["idx_par"])
                     tgt_sent_data["form"].extend(curr_sent_data["form"])
                     tgt_sent_data["lemma"].extend(curr_sent_data["lemma"])
                     tgt_sent_data["ana"].extend(curr_sent_data["ana"])
@@ -288,6 +299,7 @@ class Solar3(datasets.GeneratorBasedBuilder):
                 "id_doc": id_doc[:-1],  # doc ID without the "s" or "t" info
                 "doc_title": doc_title,
                 "is_manually_validated": is_manually_validated,
+                "idx_src_par": src_sent_data.get("idx_par", []),
                 "id_src_tokens": src_sent_data.get("id_token", []),
                 "src_tokens": src_sent_data.get("form", []),
                 "src_ling_annotations": {
@@ -297,6 +309,7 @@ class Solar3(datasets.GeneratorBasedBuilder):
                     "ne_tag": src_sent_data.get("ne_tag", []),
                     "space_after": src_sent_data.get("space_after", [])
                 },
+                "idx_tgt_par": tgt_sent_data.get("idx_par", []),
                 "id_tgt_tokens": tgt_sent_data.get("id_token", []),
                 "tgt_tokens": tgt_sent_data.get("form", []),
                 "tgt_ling_annotations": {
@@ -309,6 +322,94 @@ class Solar3(datasets.GeneratorBasedBuilder):
                 "corrections": corr_data
             }
 
+    @staticmethod
+    def aggregate_pars(sent_level_data):
+        # TODO: the code is a copypaste of the document aggregation, with an additional groupby - could use a refactor
+        uniq_idx_par = 0
+        for idx_doc, (curr_id, curr_group) in enumerate(groupby(sent_level_data, key=lambda tup: tup[1]["id_doc"])):
+            curr_instances = list(map(lambda tup: tup[1], curr_group))  # remove the redundant index info from datasets
+
+            # Some sentences have no `idx_src_par` because they are added by the teacher (not present in the source)
+            for idx_par, curr_par_group in groupby(
+                    curr_instances,
+                    key=lambda _inst: _inst["idx_src_par"][0] if len(_inst["idx_src_par"]) > 0 else
+                    _inst["idx_tgt_par"][0]
+            ):
+                src_tokens, tgt_tokens, mapped_corrections = [], [], []
+                src_ling_anns = {"lemma": [], "ana": [], "msd": [], "ne_tag": [], "space_after": []}
+                tgt_ling_anns = {"lemma": [], "ana": [], "msd": [], "ne_tag": [], "space_after": []}
+                seen_src_tokens, seen_tgt_tokens = {}, {}
+                src_base, tgt_base = 0, 0
+                prev_src_base, prev_tgt_base = 0, 0
+
+                doc_title, is_validated = None, None
+                for curr_inst in curr_par_group:
+                    doc_title, is_validated = curr_inst["doc_title"], curr_inst["is_manually_validated"]
+
+                    id_src_toks, id_tgt_toks = curr_inst["id_src_tokens"], curr_inst["id_tgt_tokens"]
+                    curr_src_toks, curr_tgt_toks = curr_inst["src_tokens"], curr_inst["tgt_tokens"]
+                    curr_src_anns, curr_tgt_anns = curr_inst["src_ling_annotations"], curr_inst["tgt_ling_annotations"]
+                    curr_corrs = curr_inst["corrections"]
+
+                    num_added_src, num_added_tgt = 0, 0
+                    for idx_position, (id_tok, tok) in enumerate(zip(id_src_toks, curr_src_toks)):
+                        if id_tok not in seen_src_tokens:
+                            src_tokens.append(tok)
+                            src_ling_anns["lemma"].append(curr_src_anns["lemma"][idx_position])
+                            src_ling_anns["ana"].append(curr_src_anns["ana"][idx_position])
+                            src_ling_anns["msd"].append(curr_src_anns["msd"][idx_position])
+                            src_ling_anns["ne_tag"].append(curr_src_anns["ne_tag"][idx_position])
+                            src_ling_anns["space_after"].append(curr_src_anns["space_after"][idx_position])
+
+                            seen_src_tokens[id_tok] = tok
+                            num_added_src += 1
+
+                    for idx_position, (id_tok, tok) in enumerate(zip(id_tgt_toks, curr_tgt_toks)):
+                        if id_tok not in seen_tgt_tokens:
+                            tgt_tokens.append(tok)
+                            tgt_ling_anns["lemma"].append(curr_tgt_anns["lemma"][idx_position])
+                            tgt_ling_anns["ana"].append(curr_tgt_anns["ana"][idx_position])
+                            tgt_ling_anns["msd"].append(curr_tgt_anns["msd"][idx_position])
+                            tgt_ling_anns["ne_tag"].append(curr_tgt_anns["ne_tag"][idx_position])
+                            tgt_ling_anns["space_after"].append(curr_tgt_anns["space_after"][idx_position])
+
+                            seen_tgt_tokens[id_tok] = tok
+                            num_added_tgt += 1
+
+                    if num_added_src == 0:
+                        src_base, prev_src_base = prev_src_base, src_base
+
+                    if num_added_tgt == 0:
+                        tgt_base, prev_tgt_base = prev_tgt_base, tgt_base
+
+                    for corr in curr_corrs:
+                        mapped_corrections.append({
+                            "idx_src": list(map(lambda _i: src_base + _i, corr["idx_src"])),
+                            "idx_tgt": list(map(lambda _i: tgt_base + _i, corr["idx_tgt"])),
+                            "corr_types": corr["corr_types"]
+                        })
+
+                    src_base += num_added_src
+                    tgt_base += num_added_tgt
+
+                    if num_added_src == 0:
+                        src_base, prev_src_base = prev_src_base, src_base
+
+                    if num_added_tgt == 0:
+                        tgt_base, prev_tgt_base = prev_tgt_base, tgt_base
+
+                yield uniq_idx_par, {
+                    "id_doc": curr_id,
+                    "doc_title": doc_title,
+                    "is_manually_validated": is_validated,
+                    "src_tokens": src_tokens,
+                    "src_ling_annotations": src_ling_anns,
+                    "tgt_tokens": tgt_tokens,
+                    "tgt_ling_annotations": tgt_ling_anns,
+                    "corrections": mapped_corrections
+                }
+                uniq_idx_par += 1
+
     @staticmethod
     def aggregate_docs(sent_level_data):
         # NOTE: assuming here that `sent_level_data` is pre-sorted by id_doc, which is done in the raw data
@@ -397,9 +498,12 @@ class Solar3(datasets.GeneratorBasedBuilder):
         sent_level_data = list(Solar3.generate_sentences(source_path, target_path, links_path))
 
         if self.config.name == "sentence_level":
-            # Remove IDs that are only useful for aggregating the document-level data
+            # Remove IDs and indices that are only useful for aggregating the document-level data
             for i, instance in sent_level_data:
-                yield i, {_k: _v for _k, _v in instance.items() if _k not in {"id_src_tokens", "id_tgt_tokens"}}
+                yield i, {_k: _v for _k, _v in instance.items() if _k not in {"id_src_tokens", "id_tgt_tokens",
+                                                                              "idx_src_par", "idx_tgt_par"}}
+        elif self.config.name == "paragraph_level":
+            yield from list(Solar3.aggregate_pars(sent_level_data))
         else:
             yield from list(Solar3.aggregate_docs(sent_level_data))