# coding=utf-8 # Copyright 2020 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. """ The BioCreative VI Chemical-Protein interaction dataset identifies entities of chemicals and proteins and their likely relation to one other. Compounds are generally agonists (activators) or antagonists (inhibitors) of proteins. The script loads dataset in bigbio schema (using knowledgebase schema: schemas/kb) AND/OR source (default) schema """ import os from typing import Dict, Tuple import datasets from .bigbiohub import kb_features from .bigbiohub import BigBioConfig from .bigbiohub import Tasks _LANGUAGES = ['English'] _PUBMED = True _LOCAL = False _CITATION = """\ @article{DBLP:journals/biodb/LiSJSWLDMWL16, author = {Krallinger, M., Rabal, O., Lourenço, A.}, title = {Overview of the BioCreative VI chemical-protein interaction Track}, journal = {Proceedings of the BioCreative VI Workshop,}, volume = {141-146}, year = {2017}, url = {https://biocreative.bioinformatics.udel.edu/tasks/biocreative-vi/track-5/}, doi = {}, biburl = {}, bibsource = {} } """ _DESCRIPTION = """\ The BioCreative VI Chemical-Protein interaction dataset identifies entities of chemicals and proteins and their likely relation to one other. Compounds are generally agonists (activators) or antagonists (inhibitors) of proteins. """ _DATASETNAME = "chemprot" _DISPLAYNAME = "ChemProt" _HOMEPAGE = "https://biocreative.bioinformatics.udel.edu/tasks/biocreative-vi/track-5/" _LICENSE = 'Public Domain Mark 1.0' _URLs = { "source": "https://biocreative.bioinformatics.udel.edu/media/store/files/2017/ChemProt_Corpus.zip", "bigbio_kb": "https://biocreative.bioinformatics.udel.edu/media/store/files/2017/ChemProt_Corpus.zip", } _SUPPORTED_TASKS = [Tasks.RELATION_EXTRACTION, Tasks.NAMED_ENTITY_RECOGNITION] _SOURCE_VERSION = "1.0.0" _BIGBIO_VERSION = "1.0.0" # Chemprot specific variables # NOTE: There are 3 examples (2 in dev, 1 in training) with CPR:0 _GROUP_LABELS = { "CPR:0": "Undefined", "CPR:1": "Part_of", "CPR:2": "Regulator", "CPR:3": "Upregulator", "CPR:4": "Downregulator", "CPR:5": "Agonist", "CPR:6": "Antagonist", "CPR:7": "Modulator", "CPR:8": "Cofactor", "CPR:9": "Substrate", "CPR:10": "Not", } class ChemprotDataset(datasets.GeneratorBasedBuilder): """BioCreative VI Chemical-Protein Interaction Task.""" SOURCE_VERSION = datasets.Version(_SOURCE_VERSION) BIGBIO_VERSION = datasets.Version(_BIGBIO_VERSION) BUILDER_CONFIGS = [ BigBioConfig( name="chemprot_full_source", version=SOURCE_VERSION, description="chemprot source schema", schema="source", subset_id="chemprot_full", ), BigBioConfig( name="chemprot_shared_task_eval_source", version=SOURCE_VERSION, description="chemprot source schema with only the relation types that were used in the shared task evaluation", schema="source", subset_id="chemprot_shared_task_eval", ), BigBioConfig( name="chemprot_bigbio_kb", version=BIGBIO_VERSION, description="chemprot BigBio schema", schema="bigbio_kb", subset_id="chemprot", ), ] DEFAULT_CONFIG_NAME = "chemprot_full_source" def _info(self): if self.config.schema == "source": features = datasets.Features( { "pmid": datasets.Value("string"), "text": datasets.Value("string"), "entities": datasets.Sequence( { "id": datasets.Value("string"), "type": datasets.Value("string"), "text": datasets.Value("string"), "offsets": datasets.Sequence(datasets.Value("int64")), } ), "relations": datasets.Sequence( { "type": datasets.Value("string"), "arg1": datasets.Value("string"), "arg2": 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): """Returns SplitGenerators.""" my_urls = _URLs[self.config.schema] data_dir = dl_manager.download_and_extract(my_urls) # Extract each of the individual folders # NOTE: omitting "extract" call cause it uses a new folder train_path = dl_manager.extract( os.path.join(data_dir, "ChemProt_Corpus/chemprot_training.zip") ) test_path = dl_manager.extract( os.path.join(data_dir, "ChemProt_Corpus/chemprot_test_gs.zip") ) dev_path = dl_manager.extract( os.path.join(data_dir, "ChemProt_Corpus/chemprot_development.zip") ) sample_path = dl_manager.extract( os.path.join(data_dir, "ChemProt_Corpus/chemprot_sample.zip") ) return [ datasets.SplitGenerator( name="sample", # should be a named split : / gen_kwargs={ "filepath": os.path.join(sample_path, "chemprot_sample"), "abstract_file": "chemprot_sample_abstracts.tsv", "entity_file": "chemprot_sample_entities.tsv", "relation_file": "chemprot_sample_relations.tsv", "gold_standard_file": "chemprot_sample_gold_standard.tsv", "split": "sample", }, ), datasets.SplitGenerator( name=datasets.Split.TRAIN, gen_kwargs={ "filepath": os.path.join(train_path, "chemprot_training"), "abstract_file": "chemprot_training_abstracts.tsv", "entity_file": "chemprot_training_entities.tsv", "relation_file": "chemprot_training_relations.tsv", "gold_standard_file": "chemprot_training_gold_standard.tsv", "split": "train", }, ), datasets.SplitGenerator( name=datasets.Split.TEST, gen_kwargs={ "filepath": os.path.join(test_path, "chemprot_test_gs"), "abstract_file": "chemprot_test_abstracts_gs.tsv", "entity_file": "chemprot_test_entities_gs.tsv", "relation_file": "chemprot_test_relations_gs.tsv", "gold_standard_file": "chemprot_test_gold_standard.tsv", "split": "test", }, ), datasets.SplitGenerator( name=datasets.Split.VALIDATION, gen_kwargs={ "filepath": os.path.join(dev_path, "chemprot_development"), "abstract_file": "chemprot_development_abstracts.tsv", "entity_file": "chemprot_development_entities.tsv", "relation_file": "chemprot_development_relations.tsv", "gold_standard_file": "chemprot_development_gold_standard.tsv", "split": "dev", }, ), ] def _generate_examples( self, filepath, abstract_file, entity_file, relation_file, gold_standard_file, split, ): """Yields examples as (key, example) tuples.""" if self.config.schema == "source": abstracts = self._get_abstract(os.path.join(filepath, abstract_file)) entities, entity_id = self._get_entities( os.path.join(filepath, entity_file) ) if self.config.subset_id == "chemprot_full": relations = self._get_relations(os.path.join(filepath, relation_file)) elif self.config.subset_id == "chemprot_shared_task_eval": relations = self._get_relations_gs( os.path.join(filepath, gold_standard_file) ) else: raise ValueError(self.config) for id_, pmid in enumerate(abstracts.keys()): yield id_, { "pmid": pmid, "text": abstracts[pmid], "entities": entities[pmid], "relations": relations.get(pmid, []), } elif self.config.schema == "bigbio_kb": abstracts = self._get_abstract(os.path.join(filepath, abstract_file)) entities, entity_id = self._get_entities( os.path.join(filepath, entity_file) ) relations = self._get_relations( os.path.join(filepath, relation_file), is_mapped=True ) uid = 0 for id_, pmid in enumerate(abstracts.keys()): data = { "id": str(uid), "document_id": str(pmid), "passages": [], "entities": [], "relations": [], "events": [], "coreferences": [], } uid += 1 data["passages"] = [ { "id": str(uid), "type": "title and abstract", "text": [abstracts[pmid]], "offsets": [[0, len(abstracts[pmid])]], } ] uid += 1 entity_to_id = {} for entity in entities[pmid]: _text = entity["text"] entity.update({"text": [_text]}) entity_to_id[entity["id"]] = str(uid) entity.update({"id": str(uid)}) _offsets = entity["offsets"] entity.update({"offsets": [_offsets]}) entity["normalized"] = [] data["entities"].append(entity) uid += 1 for relation in relations.get(pmid, []): relation["arg1_id"] = entity_to_id[relation.pop("arg1")] relation["arg2_id"] = entity_to_id[relation.pop("arg2")] relation.update({"id": str(uid)}) relation["normalized"] = [] data["relations"].append(relation) uid += 1 yield id_, data @staticmethod def _get_abstract(abs_filename: str) -> Dict[str, str]: """ For each document in PubMed ID (PMID) in the ChemProt abstract data file, return the abstract. Data is tab-separated. :param filename: `*_abstracts.tsv from ChemProt :returns Dictionary with PMID keys and abstract text as values. """ with open(abs_filename, "r") as f: contents = [i.strip() for i in f.readlines()] # PMID is the first column, Abstract is last return { doc.split("\t")[0]: "\n".join(doc.split("\t")[1:]) for doc in contents } # Includes title as line 1 @staticmethod def _get_entities(ents_filename: str) -> Tuple[Dict[str, str]]: """ For each document in the corpus, return entity annotations per PMID. Each column in the entity file is as follows: (1) PMID (2) Entity Number (3) Entity Type (Chemical, Gene-Y, Gene-N) (4) Start index (5) End index (6) Actual text of entity :param ents_filename: `_*entities.tsv` file from ChemProt :returns: Dictionary with PMID keys and entity annotations. """ with open(ents_filename, "r") as f: contents = [i.strip() for i in f.readlines()] entities = {} entity_id = {} for line in contents: pmid, idx, label, start_offset, end_offset, name = line.split("\t") # Populate entity dictionary if pmid not in entities: entities[pmid] = [] ann = { "offsets": [int(start_offset), int(end_offset)], "text": name, "type": label, "id": idx, } entities[pmid].append(ann) # Populate entity mapping entity_id.update({idx: name}) return entities, entity_id @staticmethod def _get_relations(rel_filename: str, is_mapped: bool = False) -> Dict[str, str]: """For each document in the ChemProt corpus, create an annotation for all relationships. :param is_mapped: Whether to convert into NL the relation tags. Default is OFF """ with open(rel_filename, "r") as f: contents = [i.strip() for i in f.readlines()] relations = {} for line in contents: pmid, label, _, _, arg1, arg2 = line.split("\t") arg1 = arg1.split("Arg1:")[-1] arg2 = arg2.split("Arg2:")[-1] if pmid not in relations: relations[pmid] = [] if is_mapped: label = _GROUP_LABELS[label] ann = { "type": label, "arg1": arg1, "arg2": arg2, } relations[pmid].append(ann) return relations @staticmethod def _get_relations_gs(rel_filename: str, is_mapped: bool = False) -> Dict[str, str]: """ For each document in the ChemProt corpus, create an annotation for the gold-standard relationships. The columns include: (1) PMID (2) Relationship Label (CPR) (3) Used in shared task (3) Interactor Argument 1 Entity Identifier (4) Interactor Argument 2 Entity Identifier Gold standard includes CPRs 3-9. Relationships are always Gene + Protein. Unlike entities, there is no counter, hence once must be made :param rel_filename: Gold standard file name :param ent_dict: Entity Identifier to text """ with open(rel_filename, "r") as f: contents = [i.strip() for i in f.readlines()] relations = {} for line in contents: pmid, label, arg1, arg2 = line.split("\t") arg1 = arg1.split("Arg1:")[-1] arg2 = arg2.split("Arg2:")[-1] if pmid not in relations: relations[pmid] = [] if is_mapped: label = _GROUP_LABELS[label] ann = { "type": label, "arg1": arg1, "arg2": arg2, } relations[pmid].append(ann) return relations