chemprot.py

# 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