# 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)}"