Update science_ie.py with subtask configurations and sentence splitting

science_ie.py

@@ -17,6 +17,7 @@
 import glob
 import datasets
 
+from pathlib import Path
 from itertools import permutations
 from spacy.lang.en import English
 
@@ -66,12 +67,42 @@ _URLS = {
 }
 
 
+def generate_relation(entities, arg1_id, arg2_id, relation, offset=0):
+    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, \
+        f"Did not find corresponding entities {arg1_id} & {arg2_id} in {entities}"
+    return {
+        "arg1_start": arg1["start"] - offset,
+        "arg1_end": arg1["end"] - offset,
+        "arg1_type": arg1["type"],
+        "arg2_start": arg2["start"] - offset,
+        "arg2_end": arg2["end"] - offset,
+        "arg2_type": arg2["type"],
+        "relation": relation
+    }
+
+
 class ScienceIE(datasets.GeneratorBasedBuilder):
-    """ScienceIE is a dataset for the task of extracting key phrases and relations between them from scientific documents"""
+    """ScienceIE is a dataset for the task of extracting key phrases and relations between them from scientific
+    documents"""
 
     VERSION = datasets.Version("1.0.0")
 
     BUILDER_CONFIGS = [
+        datasets.BuilderConfig(name="subtask_a", version=VERSION,
+                               description="Subtask A of ScienceIE for tokens being outside, at the beginning, "
+                                           "or inside a key phrase"),
+        datasets.BuilderConfig(name="subtask_b", version=VERSION,
+                               description="Subtask B of ScienceIE for tokens being outside, or part of a material, "
+                                           "process or task"),
+        datasets.BuilderConfig(name="subtask_c", version=VERSION,
+                               description="Subtask C of ScienceIE for Synonym-of and Hyponym-of relations"),
         datasets.BuilderConfig(name="ner", version=VERSION, description="NER part of ScienceIE"),
         datasets.BuilderConfig(name="re", version=VERSION, description="Relation extraction part of ScienceIE"),
     ]
@@ -79,7 +110,31 @@ class ScienceIE(datasets.GeneratorBasedBuilder):
     DEFAULT_CONFIG_NAME = "ner"
 
     def _info(self):
-        if self.config.name == "re":
+        if self.config.name == "subtask_a":
+            features = datasets.Features(
+                {
+                    "id": datasets.Value("string"),
+                    "tokens": datasets.Sequence(datasets.Value("string")),
+                    "tags": datasets.Sequence(datasets.features.ClassLabel(names=["O", "B", "I"]))
+                }
+            )
+        elif self.config.name == "subtask_b":
+            features = datasets.Features(
+                {
+                    "id": datasets.Value("string"),
+                    "tokens": datasets.Sequence(datasets.Value("string")),
+                    "tags": datasets.Sequence(datasets.features.ClassLabel(names=["O", "M", "P", "T"]))
+                }
+            )
+        elif self.config.name == "subtask_c":
+            features = datasets.Features(
+                {
+                    "id": datasets.Value("string"),
+                    "tokens": datasets.Sequence(datasets.Value("string")),
+                    "tags": datasets.Sequence(datasets.Sequence(datasets.features.ClassLabel(names=["O", "S", "H"])))
+                }
+            )
+        elif self.config.name == "re":
             features = datasets.Features(
                 {
                     "id": datasets.Value("string"),
@@ -90,13 +145,7 @@ class ScienceIE(datasets.GeneratorBasedBuilder):
                     "arg2_start": datasets.Value("int32"),
                     "arg2_end": datasets.Value("int32"),
                     "arg2_type": datasets.Value("string"),
-                    "relation": datasets.features.ClassLabel(
-                        names=[
-                            "O",
-                            "Synonym-of",
-                            "Hyponym-of"
-                        ]
-                    )
+                    "relation": datasets.features.ClassLabel(names=["O", "Synonym-of", "Hyponym-of"])
                 }
             )
         else:
@@ -104,16 +153,16 @@ class ScienceIE(datasets.GeneratorBasedBuilder):
                 {
                     "id": datasets.Value("string"),
                     "tokens": datasets.Sequence(datasets.Value("string")),
-                    "ner_tags": datasets.Sequence(
+                    "tags": datasets.Sequence(
                         datasets.features.ClassLabel(
                             names=[
                                 "O",
+                                "B-Material",
+                                "I-Material",
                                 "B-Process",
                                 "I-Process",
                                 "B-Task",
-                                "I-Task",
-                                "B-Material",
-                                "I-Material"
+                                "I-Task"
                             ]
                         )
                     )
@@ -151,12 +200,16 @@ class ScienceIE(datasets.GeneratorBasedBuilder):
         # The `key` is for legacy reasons (tfds) and is not important in itself, but must be unique for each example.
         annotation_files = glob.glob(dir_path + "/**/*.ann", recursive=True)
         word_splitter = English()
-        key = 0
-        for f_anno_path in annotation_files:
-            f_text_path = f_anno_path.replace(".ann", ".txt")
+        word_splitter.add_pipe('sentencizer')
+        for f_anno_file in annotation_files:
+            doc_example_idx = 0
+            f_anno_path = Path(f_anno_file)
+            f_text_path = f_anno_path.with_suffix(".txt")
+            doc_id = f_anno_path.stem
             with open(f_anno_path, mode="r", encoding="utf8") as f_anno, \
                     open(f_text_path, mode="r", encoding="utf8") as f_text:
                 text = f_text.read()
+                doc = word_splitter(text)
                 entities = []
                 synonym_groups = []
                 hyponyms = []
@@ -186,71 +239,126 @@ class ScienceIE(datasets.GeneratorBasedBuilder):
                             keyphr_text_lookup = text[int(start):int(end)]
                             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)
+                                print("Spans don't match for anno " + line.strip() + " in file " + f_anno_file)
+                            char_start = int(start)
+                            char_end = int(end)
+                            entity_span = doc.char_span(char_start, char_end, alignment_mode="expand")
+                            start = entity_span.start
+                            end = entity_span.end
                             entities.append({
                                 "id": identifier,
-                                "char_start": int(start),
-                                "char_end": int(end),
+                                "start": start,
+                                "end": end,
+                                "char_start": char_start,
+                                "char_end": char_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["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"]
+                # check if any annotation is lost during sentence splitting
+                synonym_groups_used = [False for _ in synonym_groups]
+                hyponyms_used = [False for _ in hyponyms]
+                for sent in doc.sents:
+                    token_offset = sent.start
+                    tokens = [token.text for token in sent]
+                    tags = ["O" for _ in tokens]
+                    sent_entities = []
+                    sent_entity_ids = []
+                    for entity in entities:
+                        if entity["start"] >= sent.start and entity["end"] <= sent.end:
+                            sent_entity = {k: v for k, v in entity.items()}
+                            sent_entity["start"] -= token_offset
+                            sent_entity["end"] -= token_offset
+                            sent_entities.append(sent_entity)
+                            sent_entity_ids.append(entity["id"])
+                    for entity in sent_entities:
+                        tags[entity["start"]] = "B-" + entity["type"]
+                        for i in range(entity["start"] + 1, entity["end"]):
+                            tags[i] = "I-" + entity["type"]
 
-                if self.config.name == "re":
-                    entity_pairs = list(permutations([entity["id"] for entity in entities], 2))
                     relations = []
+                    entity_pairs_in_relation = []
+                    for idx, synonym_group in enumerate(synonym_groups):
+                        if all(entity_id in sent_entity_ids for entity_id in synonym_group):
+                            synonym_groups_used[idx] = True
+                            for arg1_id, arg2_id in permutations(synonym_group, 2):
+                                relations.append(
+                                    generate_relation(sent_entities, arg1_id, arg2_id, relation="Synonym-of"))
+                                entity_pairs_in_relation.append((arg1_id, arg2_id))
+                    for idx, hyponym in enumerate(hyponyms):
+                        if hyponym["arg1_id"] in sent_entity_ids and hyponym["arg2_id"] in sent_entity_ids:
+                            hyponyms_used[idx] = True
+                            relations.append(
+                                generate_relation(sent_entities, hyponym["arg1_id"], hyponym["arg2_id"],
+                                                  relation="Hyponym-of"))
 
-                    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")
+                            entity_pairs_in_relation.append((arg1_id, arg2_id))
+                    entity_pairs = [(arg1["id"], arg2["id"]) for arg1, arg2 in permutations(sent_entities, 2)
+                                    if (arg1["id"], arg2["id"]) not in entity_pairs_in_relation]
                     for arg1_id, arg2_id in entity_pairs:
-                        add_relation(arg1_id, arg2_id, _relation="O")
-                    for relation in relations:
-                        key += 1
+                        relations.append(generate_relation(sent_entities, arg1_id, arg2_id, relation="O"))
+
+                    if self.config.name == "subtask_a":
+                        doc_example_idx += 1
+                        key = f"{doc_id}_{doc_example_idx}"
+                        # Yields examples as (key, example) tuples
+                        yield key, {
+                            "id": key,
+                            "tokens": tokens,
+                            "tags": [tag[0] for tag in tags]
+                        }
+                    elif self.config.name == "subtask_b":
+                        doc_example_idx += 1
+                        key = f"{doc_id}_{doc_example_idx}"
+                        # Yields examples as (key, example) tuples
+                        key_phrase_tags = []
+                        for tag in tags:
+                            if tag == "O":
+                                key_phrase_tags.append(tag)
+                            else:
+                                # use first letter of key phrase type
+                                key_phrase_tags.append(tag[2])
+                        yield key, {
+                            "id": key,
+                            "tokens": tokens,
+                            "tags": key_phrase_tags
+                        }
+                    elif self.config.name == "subtask_c":
+                        doc_example_idx += 1
+                        key = f"{doc_id}_{doc_example_idx}"
+                        tag_vectors = [["O" for _ in tokens] for _ in tokens]
+                        for relation in relations:
+                            tag = relation["relation"][0]
+                            if tag != "O":
+                                for i in range(relation["arg1_start"], relation["arg1_end"]):
+                                    for j in range(relation["arg2_start"], relation["arg2_end"]):
+                                        tag_vectors[i][j] = tag
+                        # Yields examples as (key, example) tuples
+                        yield key, {
+                            "id": key,
+                            "tokens": tokens,
+                            "tags": tag_vectors
+                        }
+                    elif self.config.name == "re":
+                        for relation in relations:
+                            doc_example_idx += 1
+                            key = f"{doc_id}_{doc_example_idx}"
+                            # Yields examples as (key, example) tuples
+                            example = {
+                                "id": key,
+                                "tokens": tokens
+                            }
+                            for k, v in relation.items():
+                                example[k] = v
+                            yield doc_example_idx, example
+                    else:  # NER config
+                        doc_example_idx += 1
+                        key = f"{doc_id}_{doc_example_idx}"
                         # Yields examples as (key, example) tuples
-                        example = {
-                            "id": str(key),
-                            "tokens": tokens
+                        yield key, {
+                            "id": key,
+                            "tokens": tokens,
+                            "tags": tags
                         }
-                        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
-                    }
+
+        assert all(synonym_groups_used) and all(hyponyms_used), \
+            f"Annotations were lost: {len([e for e in synonym_groups_used if e])} synonym annotations," \
+            f"{len([e for e in hyponyms_used if e])} synonym annotations"