scai_disease.py

# 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.

"""
A dataset loader for the SCAI Disease dataset.

SCAI Disease is a dataset annotated in 2010 with mentions of diseases and
adverse effects. It is a corpus containing 400 randomly selected MEDLINE
abstracts generated using ‘Disease OR Adverse effect’ as a PubMed query. This
evaluation corpus was annotated by two individuals who hold a Master’s degree
in life sciences.
"""

import os
from typing import Dict, List, Tuple

import datasets

from .bigbiohub import kb_features
from .bigbiohub import BigBioConfig
from .bigbiohub import Tasks

_LANGUAGES = ['English']
_PUBMED = True
_LOCAL = False
_CITATION = """\
@inproceedings{gurulingappa:lrec-ws10,
  author    = {Harsha Gurulingappa and Roman Klinger and Martin Hofmann-Apitius and Juliane Fluck},
  title     = {An Empirical Evaluation of Resources for the Identification of Diseases and Adverse Effects in Biomedical Literature},
  booktitle = {LREC Workshop on Building and Evaluating Resources for Biomedical Text Mining},
  year      = {2010},
}
"""

_DATASETNAME = "scai_disease"
_DISPLAYNAME = "SCAI Disease"

_DESCRIPTION = """\
SCAI Disease is a dataset annotated in 2010 with mentions of diseases and
adverse effects. It is a corpus containing 400 randomly selected MEDLINE
abstracts generated using ‘Disease OR Adverse effect’ as a PubMed query. This
evaluation corpus was annotated by two individuals who hold a Master’s degree
in life sciences.
"""

_HOMEPAGE = "https://www.scai.fraunhofer.de/en/business-research-areas/bioinformatics/downloads/corpus-for-disease-names-and-adverse-effects.html"

_LICENSE = 'License information unavailable'

_URLS = {
    _DATASETNAME: "https://www.scai.fraunhofer.de/content/dam/scai/de/downloads/bioinformatik/Disease-ae-corpus.iob",
}

_SUPPORTED_TASKS = [Tasks.NAMED_ENTITY_RECOGNITION]

_SOURCE_VERSION = "1.0.0"

_BIGBIO_VERSION = "1.0.0"


class ScaiDiseaseDataset(datasets.GeneratorBasedBuilder):
    """SCAI Disease is a dataset annotated in 2010 with mentions of diseases and
    adverse effects."""

    SOURCE_VERSION = datasets.Version(_SOURCE_VERSION)
    BIGBIO_VERSION = datasets.Version(_BIGBIO_VERSION)

    BUILDER_CONFIGS = [
        BigBioConfig(
            name="scai_disease_source",
            version=SOURCE_VERSION,
            description="SCAI Disease source schema",
            schema="source",
            subset_id="scai_disease",
        ),
        BigBioConfig(
            name="scai_disease_bigbio_kb",
            version=BIGBIO_VERSION,
            description="SCAI Disease BigBio schema",
            schema="bigbio_kb",
            subset_id="scai_disease",
        ),
    ]

    DEFAULT_CONFIG_NAME = "scai_disease_source"

    def _info(self) -> datasets.DatasetInfo:
        if self.config.schema == "source":
            features = datasets.Features(
                {
                    "document_id": datasets.Value("string"),
                    "text": datasets.Value("string"),
                    "tokens": [
                        {
                            "offsets": [datasets.Value("int64")],
                            "text": datasets.Value("string"),
                            "tag": datasets.Value("string"),
                        }
                    ],
                    "entities": [
                        {
                            "offsets": [datasets.Value("int64")],
                            "text": datasets.Value("string"),
                            "type": datasets.Value("string"),
                        }
                    ],
                }
            )

        elif self.config.schema == "bigbio_kb":
            features = kb_features
        else:
            raise ValueError("Unrecognized schema: %s" % self.config.schema)

        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."""
        url = _URLS[_DATASETNAME]
        filepath = dl_manager.download(url)

        return [
            datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                gen_kwargs={
                    "filepath": filepath,
                    "split": "train",
                },
            ),
        ]

    def _generate_examples(self, filepath, split: str) -> Tuple[int, Dict]:
        """Yields examples as (key, example) tuples."""

        # Iterates through lines in file, collecting all lines belonging
        # to an example and converting into a single dict
        examples = []
        tokens = None
        with open(filepath, "r") as data_file:
            for line in data_file:
                line = line.strip()
                if line.startswith("###"):
                    tokens = [line]
                elif line == "":
                    examples.append(self._make_example(tokens))
                else:
                    tokens.append(line)

        # Returns the examples using the desired schema
        if self.config.schema == "source":
            for i, example in enumerate(examples):
                yield i, example

        elif self.config.schema == "bigbio_kb":
            for i, example in enumerate(examples):
                bigbio_example = {
                    "id": "example-" + str(i),
                    "document_id": example["document_id"],
                    "passages": [
                        {
                            "id": "passage-" + str(i),
                            "type": "abstract",
                            "text": [example["text"]],
                            "offsets": [[0, len(example["text"])]],
                        }
                    ],
                    "entities": [],
                    "events": [],
                    "coreferences": [],
                    "relations": [],
                }

                # Converts entities to BigBio format
                for j, entity in enumerate(example["entities"]):
                    bigbio_example["entities"].append(
                        {
                            "id": "entity-" + str(i) + "-" + str(j),
                            "offsets": [entity["offsets"]],
                            "text": [entity["text"]],
                            "type": entity["type"],
                            "normalized": [],
                        }
                    )

                yield i, bigbio_example

    @staticmethod
    def _make_example(tokens):
        """
        Converts a list of lines representing tokens into an example dictionary
        formatted according to the source schema

        :param tokens: list of strings
        :return: dictionary in the source schema
        """
        document_id = tokens[0][4:]

        text = ""
        processed_tokens = []
        entities = []
        last_offset = 0

        for token in tokens[1:]:
            token_pieces = token.split("\t")
            if len(token_pieces) != 5:
                raise ValueError("Failed to parse line: %s" % token)

            token_text = str(token_pieces[0])
            token_start = int(token_pieces[1])
            token_end = int(token_pieces[2])
            entity_text = str(token_pieces[3])
            token_tag = str(token_pieces[4])[1:]

            if token_start > last_offset:
                for _ in range(token_start - last_offset):
                    text += " "
            elif token_start < last_offset:
                raise ValueError("Invalid start index: %s" % token)
            last_offset = token_end

            text += token_text
            processed_tokens.append(
                {
                    "offsets": [token_start, token_end],
                    "text": token_text,
                    "tag": token_tag,
                }
            )
            if entity_text != "":
                entities.append(
                    {
                        "offsets": [token_start, token_start + len(entity_text)],
                        "text": entity_text,
                        "type": token_tag[2:],
                    }
                )

        return {
            "document_id": document_id,
            "text": text,
            "entities": entities,
            "tokens": processed_tokens,
        }