upload hubscripts/biorelex_hub.py to hub from bigbio repo

biorelex.py

@@ -0,0 +1,416 @@
+# coding=utf-8
+# Copyright 2022 The HuggingFace Datasets Authors and the current dataset script contributor.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+BioRelEx is a biological relation extraction dataset. Version 1.0 contains 2010
+annotated sentences that describe binding interactions between various
+biological entities (proteins, chemicals, etc.). 1405 sentences are for
+training, another 201 sentences are for validation. They are publicly available
+at https://github.com/YerevaNN/BioRelEx/releases. Another 404 sentences are for
+testing which are kept private for at this Codalab competition
+https://competitions.codalab.org/competitions/20468. All sentences contain words
+"bind", "bound" or "binding". For every sentence we provide: 1) Complete
+annotations of all biological entities that appear in the sentence 2) Entity
+types (32 types) and grounding information for most of the proteins and families
+(links to uniprot, interpro and other databases) 3) Coreference between entities
+in the same sentence (e.g. abbreviations and synonyms) 4) Binding interactions
+between the annotated entities 5) Binding interaction types: positive, negative
+(A does not bind B) and neutral (A may bind to B)
+"""
+
+import itertools as it
+import json
+from collections import defaultdict
+from typing import Dict, List, Tuple
+
+import datasets
+
+from .bigbiohub import kb_features
+from .bigbiohub import BigBioConfig
+from .bigbiohub import Tasks
+
+# TODO: Add BibTeX citation
+_LANGUAGES = ['English']
+_PUBMED = True
+_LOCAL = False
+_CITATION = """\
+@inproceedings{khachatrian2019biorelex,
+    title = "{B}io{R}el{E}x 1.0: Biological Relation Extraction Benchmark",
+    author = "Khachatrian, Hrant  and
+      Nersisyan, Lilit  and
+      Hambardzumyan, Karen  and
+      Galstyan, Tigran  and
+      Hakobyan, Anna  and
+      Arakelyan, Arsen  and
+      Rzhetsky, Andrey  and
+      Galstyan, Aram",
+    booktitle = "Proceedings of the 18th BioNLP Workshop and Shared Task",
+    month = aug,
+    year = "2019",
+    address = "Florence, Italy",
+    publisher = "Association for Computational Linguistics",
+    url = "https://aclanthology.org/W19-5019",
+    doi = "10.18653/v1/W19-5019",
+    pages = "176--190"
+}
+"""
+
+_DATASETNAME = "biorelex"
+_DISPLAYNAME = "BioRelEx"
+
+_DESCRIPTION = """\
+BioRelEx is a biological relation extraction dataset. Version 1.0 contains 2010
+annotated sentences that describe binding interactions between various
+biological entities (proteins, chemicals, etc.). 1405 sentences are for
+training, another 201 sentences are for validation. They are publicly available
+at https://github.com/YerevaNN/BioRelEx/releases. Another 404 sentences are for
+testing which are kept private for at this Codalab competition
+https://competitions.codalab.org/competitions/20468. All sentences contain words
+"bind", "bound" or "binding". For every sentence we provide: 1) Complete
+annotations of all biological entities that appear in the sentence 2) Entity
+types (32 types) and grounding information for most of the proteins and families
+(links to uniprot, interpro and other databases) 3) Coreference between entities
+in the same sentence (e.g. abbreviations and synonyms) 4) Binding interactions
+between the annotated entities 5) Binding interaction types: positive, negative
+(A does not bind B) and neutral (A may bind to B)"""
+
+_HOMEPAGE = "https://github.com/YerevaNN/BioRelEx"
+
+_LICENSE = 'License information unavailable'
+
+_URLS = {
+    _DATASETNAME: {
+        "train": "https://github.com/YerevaNN/BioRelEx/releases/download/1.0alpha7/1.0alpha7.train.json",
+        "dev": "https://github.com/YerevaNN/BioRelEx/releases/download/1.0alpha7/1.0alpha7.dev.json",
+    },
+}
+
+_SUPPORTED_TASKS = [
+    Tasks.NAMED_ENTITY_RECOGNITION,
+    Tasks.NAMED_ENTITY_DISAMBIGUATION,
+    Tasks.RELATION_EXTRACTION,
+    Tasks.COREFERENCE_RESOLUTION,
+]
+
+_SOURCE_VERSION = "1.0.0"
+
+_BIGBIO_VERSION = "1.0.0"
+
+
+class BioRelExDataset(datasets.GeneratorBasedBuilder):
+    """BioRelEx is a biological relation extraction dataset."""
+
+    SOURCE_VERSION = datasets.Version(_SOURCE_VERSION)
+    BIGBIO_VERSION = datasets.Version(_BIGBIO_VERSION)
+
+    BUILDER_CONFIGS = [
+        BigBioConfig(
+            name="biorelex_source",
+            version=SOURCE_VERSION,
+            description="BioRelEx source schema",
+            schema="source",
+            subset_id="biorelex",
+        ),
+        BigBioConfig(
+            name="biorelex_bigbio_kb",
+            version=BIGBIO_VERSION,
+            description="BioRelEx BigBio schema",
+            schema="bigbio_kb",
+            subset_id="biorelex",
+        ),
+    ]
+
+    DEFAULT_CONFIG_NAME = "biorelex_source"
+
+    def _info(self) -> datasets.DatasetInfo:
+
+        if self.config.schema == "source":
+            features = datasets.Features(
+                {
+                    "paperid": datasets.Value("string"),
+                    "interactions": [
+                        {
+                            "participants": datasets.Sequence(datasets.Value("int32")),
+                            "type": datasets.Value("string"),
+                            "implicit": datasets.Value("bool"),
+                            "label": datasets.Value("int32"),
+                        }
+                    ],
+                    "url": datasets.Value("string"),
+                    "text": datasets.Value("string"),
+                    "entities": [
+                        {
+                            "is_state": datasets.Value("bool"),
+                            "label": datasets.Value("string"),
+                            "names": [
+                                {
+                                    "text": datasets.Value("string"),
+                                    "is_mentioned": datasets.Value("bool"),
+                                    "mentions": datasets.Sequence(
+                                        [datasets.Value("int32")]
+                                    ),
+                                }
+                            ],
+                            "grounding": [
+                                {
+                                    "comment": datasets.Value("string"),
+                                    "entrez_gene": datasets.Value("string"),
+                                    "source": datasets.Value("string"),
+                                    "link": datasets.Value("string"),
+                                    "hgnc_symbol": datasets.Value("string"),
+                                    "organism": datasets.Value("string"),
+                                }
+                            ],
+                            "is_mentioned": datasets.Value("bool"),
+                            "is_mutant": datasets.Value("bool"),
+                        }
+                    ],
+                    "_line_": datasets.Value("int32"),
+                    "id": datasets.Value("string"),
+                }
+            )
+        elif self.config.schema == "bigbio_kb":
+            features = kb_features
+
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=features,
+            homepage=_HOMEPAGE,
+            license=str(_LICENSE),
+            citation=_CITATION,
+        )
+
+    def _split_generators(self, dl_manager) -> List[datasets.SplitGenerator]:
+        """Returns SplitGenerators."""
+
+        urls = _URLS[_DATASETNAME]
+        data_dir = dl_manager.download_and_extract(urls)
+
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={
+                    "filepath": data_dir["train"],
+                },
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.VALIDATION,
+                gen_kwargs={
+                    "filepath": data_dir["dev"],
+                },
+            ),
+        ]
+
+    def _generate_examples(self, filepath) -> Tuple[int, Dict]:
+        """Yields examples as (key, example) tuples."""
+
+        with open(filepath, "r", encoding="utf8") as f:
+            data = json.load(f)
+        data = self._prep(data)
+
+        if self.config.schema == "source":
+            for key, example in enumerate(data):
+                yield key, example
+
+        elif self.config.schema == "bigbio_kb":
+            for key, example in enumerate(data):
+                example_ = self._source_to_kb(example)
+                yield key, example_
+
+    def _prep(self, data):
+        for example in data:
+            for entity in example["entities"]:
+                entity["names"] = self._json_dict_to_list(entity["names"], "text")
+                if entity["grounding"] is None:
+                    entity["grounding"] = []
+                else:
+                    entity["grounding"] = [entity["grounding"]]
+        return data
+
+    def _json_dict_to_list(self, json, new_key):
+        list_ = []
+        for key, values in json.items():
+            assert isinstance(values, dict), "Child element is not a dict"
+            assert new_key not in values, "New key already in values"
+            values[new_key] = key
+            list_.append(values)
+        return list_
+
+    def _source_to_kb(self, example):
+        example_id = example["id"]
+        entities_, corefs_, ref_id_map = self._get_entities(
+            example_id, example["entities"]
+        )
+        relations_ = self._get_relations(
+            example_id, ref_id_map, example["interactions"]
+        )
+
+        document_ = {
+            "id": example_id,
+            "document_id": example["paperid"],
+            "passages": [
+                {
+                    "id": example_id + ".sent",
+                    "type": "sentence",
+                    "text": [example["text"]],
+                    "offsets": [[0, len(example["text"])]],
+                }
+            ],
+            "entities": entities_,
+            "coreferences": corefs_,
+            "relations": relations_,
+            "events": [],
+        }
+        return document_
+
+    def _get_entities(self, example_id, entities):
+        entities_ = []
+        corefs_ = []
+
+        eid = it.count(0)
+        cid = it.count(0)
+        # dictionary mapping the original ref ids (indexes of entities) for relations
+        org_rel_ref_id_2_kb_entity_id = defaultdict(list)
+
+        for relation_ref_id, entity in enumerate(entities):
+
+            # get normalization for entities
+            normalized_ = self._get_normalizations(entity)
+
+            # create entity for each synonym
+            coref_eids_ = []
+            for names in entity["names"]:
+                for id, mention in enumerate(names["mentions"]):
+                    entity_id = example_id + ".ent" + str(next(eid)) + "_" + str(id)
+                    org_rel_ref_id_2_kb_entity_id[relation_ref_id].append(entity_id)
+                    coref_eids_.append(entity_id)
+                    entities_.append(
+                        {
+                            "id": entity_id,
+                            "type": entity["label"],
+                            "text": [names["text"]],
+                            "offsets": [mention],
+                            "normalized": normalized_,
+                        }
+                    )
+
+            # create coreferences
+            coref_id = example_id + ".coref" + str(next(cid))
+            corefs_.append(
+                {
+                    "id": coref_id,
+                    "entity_ids": coref_eids_,
+                }
+            )
+        return entities_, corefs_, org_rel_ref_id_2_kb_entity_id
+
+    def _get_normalizations(self, entity):
+        normalized_ = []
+        if entity["grounding"]:
+            assert len(entity["grounding"]) == 1
+            if entity["grounding"][0]["entrez_gene"] != "NA":
+                normalized_.append(
+                    {
+                        "db_name": "NCBI gene",
+                        "db_id": entity["grounding"][0]["entrez_gene"],
+                    }
+                )
+            if entity["grounding"][0]["hgnc_symbol"] != "NA":
+                normalized_.append(
+                    {"db_name": "hgnc", "db_id": entity["grounding"][0]["hgnc_symbol"]}
+                )
+
+            # maybe parse some other ids?
+            source = entity["grounding"][0]["source"]
+            if (
+                source != "NCBI gene"
+                and source != "https://www.genenames.org/data/genegroup/"
+            ):  # NCBI gene is same as entrez
+                normalized_.append(
+                    self._parse_id_from_link(
+                        entity["grounding"][0]["link"], entity["grounding"][0]["source"]
+                    )
+                )
+        return normalized_
+
+    def _get_relations(self, example_id, org_rel_ref_id_2_kb_entity_id, interactions):
+        rid = it.count(0)
+        relations_ = []
+        for interaction in interactions:
+            rel_id = example_id + ".rel" + str(next(rid))
+            assert len(interaction["participants"]) == 2
+
+            subjects = org_rel_ref_id_2_kb_entity_id[interaction["participants"][0]]
+            objects = org_rel_ref_id_2_kb_entity_id[interaction["participants"][1]]
+
+            for s in subjects:
+                for o in objects:
+                    relations_.append(
+                        {
+                            "id": rel_id + "s" + s + ".o" + o,
+                            "type": interaction["type"],
+                            "arg1_id": s,
+                            "arg2_id": o,
+                            "normalized": [],
+                        }
+                    )
+        return relations_
+
+    def _parse_id_from_link(self, link, source):
+        source_template_map = {
+            "uniprot": ["https://www.uniprot.org/uniprot/"],
+            "pubchem:compound": ["https://pubchem.ncbi.nlm.nih.gov/compound/"],
+            "pubchem:substance": ["https://pubchem.ncbi.nlm.nih.gov/substance/"],
+            "pfam": ["https://pfam.xfam.org/family/", "http://pfam.xfam.org/family/"],
+            "interpro": [
+                "http://www.ebi.ac.uk/interpro/entry/",
+                "https://www.ebi.ac.uk/interpro/entry/",
+            ],
+            "DrugBank": ["https://www.drugbank.ca/drugs/"],
+        }
+
+        # fix exceptions manually
+        if source == "https://enzyme.expasy.org/EC/2.5.1.18" and link == source:
+            return {"db_name": "intenz", "db_id": "2.5.1.18"}
+        elif (
+            source == "https://www.genome.jp/kegg-bin/show_pathway?map=ko04120"
+            and link == source
+        ):
+            return {"db_name": "kegg", "db_id": "ko04120"}
+        elif (
+            source == "https://www.genome.jp/dbget-bin/www_bget?enzyme+2.7.11.1"
+            and link == source
+        ):
+            return {"db_name": "intenz", "db_id": "2.7.11.1"}
+        elif (
+            source == "http://www.chemspider.com/Chemical-Structure.7995676.html"
+            and link == source
+        ):
+            return {"db_name": "chemspider", "db_id": "7995676"}
+        elif source == "intenz":
+            id = link.split("=")[0]
+            return {"db_name": source, "db_id": id}
+        else:
+            link_templates = source_template_map[source]
+            for template in link_templates:
+                if link.startswith(template):
+                    id = link.replace(template, "")
+                    id = id.split("?")[0]
+                    assert "/" not in id
+                    return {"db_name": source, "db_id": id}
+
+            assert (
+                False
+            ), f"No template found for {link}, choices: {repr(link_templates)}"