Upload indocoref.py with huggingface_hub

indocoref.py

@@ -0,0 +1,248 @@
+import os
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+try:
+    from typing import TypedDict
+except:
+    from typing_extensions import TypedDict
+
+import datasets
+
+from nusacrowd.nusa_datasets.indocoref.utils.text_preprocess import \
+    TextPreprocess
+from nusacrowd.utils import schemas
+from nusacrowd.utils.configs import NusantaraConfig
+from nusacrowd.utils.constants import Tasks
+
+_CITATION = """\
+@inproceedings{artari-etal-2021-multi,
+  title        = {A Multi-Pass Sieve Coreference Resolution for {I}ndonesian},
+  author       = {Artari, Valentina Kania Prameswara  and Mahendra, Rahmad  and Jiwanggi, Meganingrum Arista  and Anggraito, Adityo  and Budi, Indra},
+  year         = 2021,
+  month        = sep,
+  booktitle    = {Proceedings of the International Conference on Recent Advances in Natural Language Processing (RANLP 2021)},
+  publisher    = {INCOMA Ltd.},
+  address      = {Held Online},
+  pages        = {79--85},
+  url          = {https://aclanthology.org/2021.ranlp-1.10},
+  abstract     = {Coreference resolution is an NLP task to find out whether the set of referring expressions belong to the same concept in discourse. A multi-pass sieve is a deterministic coreference model that implements several layers of sieves, where each sieve takes a pair of correlated mentions from a collection of non-coherent mentions. The multi-pass sieve is based on the principle of high precision, followed by increased recall in each sieve. In this work, we examine the portability of the multi-pass sieve coreference resolution model to the Indonesian language. We conduct the experiment on 201 Wikipedia documents and the multi-pass sieve system yields 72.74{\%} of MUC F-measure and 52.18{\%} of BCUBED F-measure.}
+}
+"""
+
+_LOCAL = False
+_LANGUAGES = ["ind"]  # We follow ISO639-3 language code (https://iso639-3.sil.org/code_tables/639/data)
+_DATASETNAME = "indocoref"
+_DESCRIPTION = """\
+Dataset contains articles from Wikipedia Bahasa Indonesia which fulfill these conditions:
+- The pages contain many noun phrases, which the authors subjectively pick: (i) fictional plots, e.g., subtitles for films,
+  TV show episodes, and novel stories; (ii) biographies (incl. fictional characters); and (iii) historical events or important events.
+- The pages contain significant variation of pronoun and named-entity. We count the number of first, second, third person pronouns,
+  and clitic pronouns in the document by applying string matching.We examine the number
+of named-entity using the Stanford CoreNLP
+NER Tagger (Manning et al., 2014) with a
+model trained from the Indonesian corpus
+taken from Alfina et al. (2016).
+The Wikipedia texts have length of 500 to
+2000 words.
+We sample 201 of pages from subset of filtered
+Wikipedia pages. We hire five annotators who are
+undergraduate student in Linguistics department.
+They are native in Indonesian. Annotation is carried out using the Script d’Annotation des Chanes
+de Rfrence (SACR), a web-based Coreference resolution annotation tool developed by Oberle (2018).
+From the 201 texts, there are 16,460 mentions
+tagged by the annotators
+"""
+
+_HOMEPAGE = "https://github.com/valentinakania/indocoref/"
+_LICENSE = "MIT"
+_URLS = {
+    _DATASETNAME: "https://github.com/valentinakania/indocoref/archive/refs/heads/main.zip",
+}
+_SUPPORTED_TASKS = [Tasks.COREFERENCE_RESOLUTION]
+# Does not seem to have versioning
+_SOURCE_VERSION = "1.0.0"
+_NUSANTARA_VERSION = "1.0.0"
+
+
+class Indocoref(datasets.GeneratorBasedBuilder):
+    """A collection of 210 curated articles from Wikipedia Bahasa Indonesia with Coreference Annotations"""
+
+    SOURCE_VERSION = datasets.Version(_SOURCE_VERSION)
+    NUSANTARA_VERSION = datasets.Version(_NUSANTARA_VERSION)
+
+    BUILDER_CONFIGS = [
+        NusantaraConfig(
+            name="indocoref_source",
+            version=SOURCE_VERSION,
+            description="Indocoref source schema",
+            schema="source",
+            subset_id="indocoref",
+        ),
+        NusantaraConfig(
+            name="indocoref_nusantara_kb",
+            version=NUSANTARA_VERSION,
+            description="Indocoref Nusantara schema",
+            schema="nusantara_kb",
+            subset_id="indocoref",
+        ),
+    ]
+
+    DEFAULT_CONFIG_NAME = "indocoref_source"
+
+    def _info(self) -> datasets.DatasetInfo:
+        # The dataset does not really come with a schema, the features here come from the returned value
+        # of the accompanying utils files.
+        if self.config.schema == "source":
+            features = datasets.Features(
+                {
+                    "id": datasets.Value("int64"),
+                    "passage": datasets.Value("string"),
+                    "mentions": [
+                        {
+                            "id": datasets.Value("int64"),
+                            # Two entities which share a label are coreferences
+                            "labels": datasets.Sequence(datasets.Value("string")),
+                            "class": datasets.Value("string"),
+                            "text": datasets.Value("string"),
+                            "pronoun": datasets.Value("bool"),
+                            "proper": datasets.Value("bool"),
+                            "sent": datasets.Value("int32"),
+                            "cluster": datasets.Value("int32"),
+                            "per": datasets.Value("bool"),
+                            "org": datasets.Value("bool"),
+                            "loc": datasets.Value("bool"),
+                            "ner": datasets.Value("bool"),
+                            # "offset" is only available after modifying the original util class
+                            # "offset": datasets.Sequence(datasets.Value("int32"))
+                            # POS tags were originally available but removed due to polyglot icu dependency
+                            # polyglot.Text(passage, hint_language_code='id')
+                        }
+                    ],
+                }
+            )
+        elif self.config.schema == "nusantara_kb":
+            features = schemas.kb_features
+
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=features,
+            homepage=_HOMEPAGE,
+            license=_LICENSE,
+            citation=_CITATION,
+        )
+
+    class ReadPassage(TypedDict):
+        passage: str
+        annotated: str
+        mentions: List[any]
+
+    def _split_generators(self, dl_manager: datasets.DownloadManager) -> List[datasets.SplitGenerator]:
+        """Returns SplitGenerators."""
+        urls = _URLS[_DATASETNAME]
+        base_path = Path(dl_manager.download_and_extract(urls)) / "indocoref-main" / "data"
+        passage_path = base_path / "passage"
+        annotated_path = base_path / "annotated"
+        mentions_per_file = TextPreprocess(annotated_path).run(0)
+
+        data: List[self.ReadPassage] = []
+        for passage_file_name, annotated_file_name in zip(sorted(os.listdir(passage_path)), sorted(os.listdir(annotated_path))):
+            passage_file_path, annotated_file_path = passage_path / passage_file_name, annotated_path / annotated_file_name
+
+            if os.path.isfile(passage_file_path) and os.path.isfile(annotated_file_path):
+                with open(passage_file_path, "r") as fpassage, open(annotated_file_path, "r") as fannotated:
+                    data.append(self.ReadPassage(passage=fpassage.read(), annotated=fannotated.read(), mentions=mentions_per_file[annotated_file_name]))
+
+        # Dataset has no predefined splits, using datasets.Split.TRAIN for all of the data.
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={
+                    "data": data,
+                    "split": "train",
+                },
+            ),
+        ]
+
+    class DisjointSet:
+        parent = {}
+
+        def __init__(self, items):
+            for item in items:
+                self.parent[item] = item
+
+        def find(self, k):
+            if self.parent[k] == k:
+                return k
+            return self.find(self.parent[k])
+
+        def union(self, a, b):
+            x = self.find(a)
+            y = self.find(b)
+            self.parent[x] = y
+
+    def _generate_examples(self, data: List[ReadPassage], split: str) -> Tuple[int, Dict]:
+        """Yields examples as (key, example) tuples."""
+        if self.config.schema == "source":
+            for index, example in enumerate(data):
+                passage, mentions = example["passage"], example["mentions"]
+                row = {
+                    "id": index,
+                    "passage": passage,
+                    "mentions": [
+                        {
+                            "id": mention["id"],
+                            "labels": mention["labels"],
+                            "class": mention["class"],
+                            "text": mention["text"],
+                            "pronoun": mention["pronoun"],
+                            "proper": mention["proper"],
+                            "sent": mention["sent"],
+                            "cluster": mention["cluster"],
+                            "per": mention["per"],
+                            "org": mention["org"],
+                            "loc": mention["loc"],
+                            "ner": mention["ner"],
+                        }
+                        for mention in mentions
+                    ],
+                }
+                yield index, row
+
+        elif self.config.schema == "nusantara_kb":
+            for index, example in enumerate(data):
+                passage, mentions = example["passage"], example["mentions"]
+                # Annotated text does not have any line breaks but the original passage does
+                passage = passage.replace(" \n", " ")
+                passage = passage.replace("\n", " ")
+                all_labels = {label for mention in mentions for label in mention["labels"]}
+                labels_disjoint_set = self.DisjointSet(all_labels)
+                for mention in mentions:
+                    for i in range(1, len(mention["labels"])):
+                        labels_disjoint_set.union(mention["labels"][i], mention["labels"][i - 1])
+                coreferences = {}
+                for mention in mentions:
+                    coreference_id = labels_disjoint_set.find(mention["labels"][0])
+                    if coreference_id not in coreferences:
+                        coreferences[coreference_id] = []
+                    coreferences[coreference_id].append(str(mention["id"]))
+
+                row_id = str(index)
+                row = {
+                    "id": row_id,
+                    "passages": [{"id": "passage-" + row_id, "type": "text", "text": [passage], "offsets": [[0, len(passage)]]}],
+                    "entities": [
+                        {
+                            "id": row_id + "-entity-" + str(mention["id"]),
+                            "type": mention["class"],
+                            "text": [mention["text"]],
+                            "offsets": [list(mention["offset"])],
+                            "normalized": [],
+                        }
+                        for mention in mentions
+                    ],
+                    "coreferences": [{"id": row_id + "-coreference-" + str(coref_id), "entity_ids": [row_id + "-entity-" + entity_id for entity_id in entity_ids]} for coref_id, entity_ids in enumerate(coreferences.values())],
+                    "events": [],
+                    "relations": [],
+                }
+                yield index, row