Add RE configuration to science_ie.py

science_ie.py

@@ -16,6 +16,8 @@
 
 import glob
 import datasets
+
+from itertools import permutations
 from spacy.lang.en import English
 
 # Find for instance the citation on arxiv or on the dataset repo/website
@@ -70,31 +72,53 @@ class ScienceIE(datasets.GeneratorBasedBuilder):
     VERSION = datasets.Version("1.0.0")
 
     BUILDER_CONFIGS = [
-        datasets.BuilderConfig(name="ner", version=VERSION, description="NER part of ScienceIE")
+        datasets.BuilderConfig(name="ner", version=VERSION, description="NER part of ScienceIE"),
+        datasets.BuilderConfig(name="re", version=VERSION, description="Relation extraction part of ScienceIE"),
     ]
 
     DEFAULT_CONFIG_NAME = "ner"
 
     def _info(self):
-        features = datasets.Features(
-            {
-                "id": datasets.Value("string"),
-                "tokens": datasets.Sequence(datasets.Value("string")),
-                "ner_tags": datasets.Sequence(
-                    datasets.features.ClassLabel(
+        if self.config.name == "re":
+            features = datasets.Features(
+                {
+                    "id": datasets.Value("string"),
+                    "tokens": datasets.Value("string"),
+                    "arg1_start": datasets.Value("int32"),
+                    "arg1_end": datasets.Value("int32"),
+                    "arg1_type": datasets.Value("string"),
+                    "arg2_start": datasets.Value("int32"),
+                    "arg2_end": datasets.Value("int32"),
+                    "arg2_type": datasets.Value("string"),
+                    "relation": datasets.features.ClassLabel(
                         names=[
                             "O",
-                            "B-Process",
-                            "I-Process",
-                            "B-Task",
-                            "I-Task",
-                            "B-Material",
-                            "I-Material"
+                            "Synonym-of",
+                            "Hyponym-of"
                         ]
                     )
-                )
-            }
-        )
+                }
+            )
+        else:
+            features = datasets.Features(
+                {
+                    "id": datasets.Value("string"),
+                    "tokens": datasets.Sequence(datasets.Value("string")),
+                    "ner_tags": datasets.Sequence(
+                        datasets.features.ClassLabel(
+                            names=[
+                                "O",
+                                "B-Process",
+                                "I-Process",
+                                "B-Task",
+                                "I-Task",
+                                "B-Material",
+                                "I-Material"
+                            ]
+                        )
+                    )
+                }
+            )
         return datasets.DatasetInfo(
             # This is the description that will appear on the datasets page.
             description=_DESCRIPTION,
@@ -134,41 +158,99 @@ class ScienceIE(datasets.GeneratorBasedBuilder):
                     open(f_text_path, mode="r", encoding="utf8") as f_text:
                 text = f_text.read()
                 entities = []
+                synonym_groups = []
+                hyponyms = []
                 for line in f_anno:
-                    anno_inst = line.strip("\n").split("\t")
-                    if len(anno_inst) == 3:
-                        anno_inst1 = anno_inst[1].split(" ")
-                        if len(anno_inst1) == 3:
-                            keytype, start, end = anno_inst1
+                    split_line = line.strip("\n").split("\t")
+                    identifier = split_line[0]
+                    annotation = split_line[1].split(" ")
+                    key_type = annotation[0]
+                    if key_type == "Synonym-of":
+                        synonym_ids = annotation[1:]
+                        synonym_groups.append(synonym_ids)
+                    else:
+                        if len(annotation) == 3:
+                            _, start, end = annotation
+                        else:
+                            _, start, _, end = annotation
+                        if key_type == "Hyponym-of":
+                            assert start.startswith("Arg1:") and end.startswith("Arg2:")
+                            hyponyms.append({
+                                "id": identifier,
+                                "arg1_id": start[5:],
+                                "arg2_id": end[5:]
+                            })
                         else:
-                            keytype, start, _, end = anno_inst1
-                        if not keytype.endswith("-of"):     # NER annotation, relation annotation contains "-of"
+                            # NER annotation
                             # look up span in text and print error message if it doesn't match the .ann span text
                             keyphr_text_lookup = text[int(start):int(end)]
-                            keyphr_ann = anno_inst[2]
+                            keyphr_ann = split_line[2]
                             if keyphr_text_lookup != keyphr_ann:
                                 print("Spans don't match for anno " + line.strip() + " in file " + f_anno_path)
-
                             entities.append({
-                                "id": anno_inst[0],
-                                "start": int(start),
-                                "end": int(end),
-                                "type": keytype
+                                "id": identifier,
+                                "char_start": int(start),
+                                "char_end": int(end),
+                                "type": key_type
                             })
                 doc = word_splitter(text)
                 tokens = [token.text for token in doc]
                 ner_tags = ["O" for _ in tokens]
                 for entity in entities:
-                    entity_span = doc.char_span(entity["start"], entity["end"], alignment_mode="expand")
-                    entity_start = entity_span.start
-                    entity_end = entity_span.end
-                    ner_tags[entity_start] = "B-" + entity["type"]
-                    for i in range(entity_start + 1, entity_end):
+                    entity_span = doc.char_span(entity["char_start"], entity["char_end"], alignment_mode="expand")
+                    entity["start"] = entity_span.start
+                    entity["end"] = entity_span.end
+                    ner_tags[entity["start"]] = "B-" + entity["type"]
+                    for i in range(entity["start"] + 1, entity["end"]):
                         ner_tags[i] = "I-" + entity["type"]
-                key += 1
-                # Yields examples as (key, example) tuples
-                yield key, {
-                    "id": str(key),
-                    "tokens": tokens,
-                    "ner_tags": ner_tags
-                }
+
+                if self.config.name == "re":
+                    entity_pairs = list(permutations([entity["id"] for entity in entities], 2))
+                    relations = []
+
+                    def add_relation(_arg1_id, _arg2_id, _relation):
+                        arg1 = None
+                        arg2 = None
+                        for e in entities:
+                            if e["id"] == _arg1_id:
+                                arg1 = e
+                            elif e["id"] == _arg2_id:
+                                arg2 = e
+                        assert arg1 is not None and arg2 is not None
+                        relations.append({
+                            "arg1_start": arg1["start"],
+                            "arg1_end": arg1["end"],
+                            "arg1_type": arg1["type"],
+                            "arg2_start": arg2["start"],
+                            "arg2_end": arg2["end"],
+                            "arg2_type": arg2["type"],
+                            "relation": _relation
+                        })
+                        # noinspection PyTypeChecker
+                        entity_pairs.remove((_arg1_id, _arg2_id))
+
+                    for synonym_group in synonym_groups:
+                        for arg1_id, arg2_id in permutations(synonym_group, 2):
+                            add_relation(arg1_id, arg2_id, _relation="Synonym-of")
+                    for hyponym in hyponyms:
+                        add_relation(hyponym["arg1_id"], hyponym["arg2_id"], _relation="Hyponym-of")
+                    for arg1_id, arg2_id in entity_pairs:
+                        add_relation(arg1_id, arg2_id, _relation="O")
+                    for relation in relations:
+                        key += 1
+                        # Yields examples as (key, example) tuples
+                        example = {
+                            "id": str(key),
+                            "tokens": tokens
+                        }
+                        for k, v in relation.items():
+                            example[k] = v
+                        yield key, example
+                else:
+                    key += 1
+                    # Yields examples as (key, example) tuples
+                    yield key, {
+                        "id": str(key),
+                        "tokens": tokens,
+                        "ner_tags": ner_tags
+                    }