chia.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 large annotated corpus of patient eligibility criteria extracted from 1,000
interventional, Phase IV clinical trials registered in ClinicalTrials.gov. This
dataset includes 12,409 annotated eligibility criteria, represented by 41,487
distinctive entities of 15 entity types and 25,017 relationships of 12
relationship types."""
from pathlib import Path
from typing import Dict, Iterator, List, Tuple

import datasets

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


_LANGUAGES = ['English']
_PUBMED = False
_LOCAL = False
_CITATION = """\
@article{kury2020chia,
  title        = {Chia, a large annotated corpus of clinical trial eligibility criteria},
  author       = {
    Kury, Fabr{\'\\i}cio and Butler, Alex and Yuan, Chi and Fu, Li-heng and
    Sun, Yingcheng and Liu, Hao and Sim, Ida and Carini, Simona and Weng,
    Chunhua
  },
  year         = 2020,
  journal      = {Scientific data},
  publisher    = {Nature Publishing Group},
  volume       = 7,
  number       = 1,
  pages        = {1--11}
}
"""

_DATASETNAME = "chia"
_DISPLAYNAME = "CHIA"

_DESCRIPTION = """\
A large annotated corpus of patient eligibility criteria extracted from 1,000
interventional, Phase IV clinical trials registered in ClinicalTrials.gov. This
dataset includes 12,409 annotated eligibility criteria, represented by 41,487
distinctive entities of 15 entity types and 25,017 relationships of 12
relationship types.
"""

_HOMEPAGE = "https://github.com/WengLab-InformaticsResearch/CHIA"

_LICENSE = 'Creative Commons Attribution 4.0 International'

_URLS = {
    _DATASETNAME: "https://figshare.com/ndownloader/files/21728850",
    _DATASETNAME + "_wo_scope": "https://figshare.com/ndownloader/files/21728853",
}

_SUPPORTED_TASKS = [Tasks.NAMED_ENTITY_RECOGNITION, Tasks.RELATION_EXTRACTION]

_SOURCE_VERSION = "2.0.0"
_BIGBIO_VERSION = "1.0.0"

# For further information see appendix of the publication
_DOMAIN_ENTITY_TYPES = [
    "Condition",
    "Device",
    "Drug",
    "Measurement",
    "Observation",
    "Person",
    "Procedure",
    "Visit",
]

# For further information see appendix of the publication
_FIELD_ENTITY_TYPES = [
    "Temporal",
    "Value",
]

# For further information see appendix of the publication
_CONSTRUCT_ENTITY_TYPES = [
    "Scope",  # Not part of the "without scope" schema / version
    "Negation",
    "Multiplier",
    "Qualifier",
    "Reference_point",
    "Mood",
]

_ALL_ENTITY_TYPES = _DOMAIN_ENTITY_TYPES + _FIELD_ENTITY_TYPES + _CONSTRUCT_ENTITY_TYPES

_RELATION_TYPES = [
    "AND",
    "OR",
    "SUBSUMES",
    "HAS_NEGATION",
    "HAS_MULTIPLIER",
    "HAS_QUALIFIER",
    "HAS_VALUE",
    "HAS_TEMPORAL",
    "HAS_INDEX",
    "HAS_MOOD",
    "HAS_CONTEXT ",
    "HAS_SCOPE",  # Not part of the "without scope" schema / version
]

_MAX_OFFSET_CORRECTION = 100


class ChiaDataset(datasets.GeneratorBasedBuilder):
    """
    A large annotated corpus of patient eligibility criteria extracted from 1,000 interventional,
    Phase IV clinical trials registered in ClinicalTrials.gov.
    """

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

    BUILDER_CONFIGS = [
        BigBioConfig(
            name="chia_source",
            version=SOURCE_VERSION,
            description="Chia source schema",
            schema="source",
            subset_id="chia",
        ),
        BigBioConfig(
            name="chia_fixed_source",
            version=SOURCE_VERSION,
            description="Chia source schema (with fixed entity offsets)",
            schema="source",
            subset_id="chia_fixed",
        ),
        BigBioConfig(
            name="chia_without_scope_source",
            version=SOURCE_VERSION,
            description="Chia without scope source schema",
            schema="source",
            subset_id="chia_without_scope",
        ),
        BigBioConfig(
            name="chia_without_scope_fixed_source",
            version=SOURCE_VERSION,
            description="Chia without scope source schema (with fixed entity offsets)",
            schema="source",
            subset_id="chia_without_scope_fixed",
        ),
        BigBioConfig(
            name="chia_bigbio_kb",
            version=BIGBIO_VERSION,
            description="Chia BigBio schema",
            schema="bigbio_kb",
            subset_id="chia",
        ),
    ]

    DEFAULT_CONFIG_NAME = "chia_source"

    def _info(self):
        if self.config.schema == "source":
            features = datasets.Features(
                {
                    "id": datasets.Value("string"),
                    "document_id": datasets.Value(
                        "string"
                    ),  # NCT-ID from clinicialtrials.gov
                    "text": datasets.Value("string"),
                    "text_type": datasets.Value(
                        "string"
                    ),  # inclusion or exclusion (criteria)
                    "entities": [
                        {
                            "id": datasets.Value("string"),
                            "type": datasets.Value("string"),
                            "text": datasets.Sequence(datasets.Value("string")),
                            "offsets": datasets.Sequence([datasets.Value("int32")]),
                            "normalized": [
                                {
                                    "db_name": datasets.Value("string"),
                                    "db_id": datasets.Value("string"),
                                }
                            ],
                        }
                    ],
                    "relations": [
                        {
                            "id": datasets.Value("string"),
                            "type": datasets.Value("string"),
                            "arg1_id": datasets.Value("string"),
                            "arg2_id": datasets.Value("string"),
                            "normalized": [
                                {
                                    "db_name": datasets.Value("string"),
                                    "db_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):
        url_key = _DATASETNAME

        if self.config.subset_id.startswith("chia_without_scope"):
            url_key += "_wo_scope"

        urls = _URLS[url_key]
        data_dir = dl_manager.download_and_extract(urls)

        return [
            datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                gen_kwargs={"file_paths": dl_manager.iter_files(data_dir)},
            )
        ]

    def _generate_examples(self, file_paths: Iterator[str]) -> Iterator[Tuple[str, Dict]]:
        if self.config.schema == "source":
            fix_offsets = "fixed" in self.config.subset_id

            for file_path in file_paths:
                file = Path(file_path)
                if not file.name.endswith(".txt"):
                    continue

                brat_example = parse_brat_file(file, [".ann"])
                source_example = self._to_source_example(
                    file, brat_example, fix_offsets
                )
                yield source_example["id"], source_example

        elif self.config.schema == "bigbio_kb":
            for file_path in file_paths:
                file = Path(file_path)
                if not file.name.endswith(".txt"):
                    continue

                brat_example = parse_brat_file(file, [".ann"])
                source_example = self._to_source_example(file, brat_example, True)

                bigbio_example = {
                    "id": source_example["id"],
                    "document_id": source_example["document_id"],
                    "passages": [
                        {
                            "id": source_example["id"] + "_text",
                            "type": source_example["text_type"],
                            "text": [source_example["text"]],
                            "offsets": [[0, len(source_example["text"])]],
                        }
                    ],
                    "entities": source_example["entities"],
                    "relations": source_example["relations"],
                    "events": [],
                    "coreferences": [],
                }

                yield bigbio_example["id"], bigbio_example

    def _to_source_example(
        self, input_file: Path, brat_example: Dict, fix_offsets: bool
    ) -> Dict:
        """
        Converts the generic brat example to the source schema format.
        """
        example_id = str(input_file.stem)
        document_id = example_id.split("_")[0]
        criteria_type = "inclusion" if "_inc" in input_file.stem else "exclusion"

        text = brat_example["text"]

        source_example = {
            "id": example_id,
            "document_id": document_id,
            "text_type": criteria_type,
            "text": text,
            "entities": [],
            "relations": [],
        }

        example_prefix = example_id + "_"
        entity_ids = {}

        for tb_annotation in brat_example["text_bound_annotations"]:
            if tb_annotation["type"].capitalize() not in _ALL_ENTITY_TYPES:
                continue

            entity_ann = tb_annotation.copy()
            entity_ann["id"] = example_prefix + entity_ann["id"]
            entity_ids[entity_ann["id"]] = True

            if fix_offsets:
                if len(entity_ann["offsets"]) > 1:
                    entity_ann["text"] = self._get_texts_for_multiple_offsets(
                        text, entity_ann["offsets"]
                    )

                fixed_offsets = []
                fixed_texts = []
                for entity_text, offsets in zip(
                    entity_ann["text"], entity_ann["offsets"]
                ):
                    fixed_offset = self._fix_entity_offsets(text, entity_text, offsets)
                    fixed_offsets.append(fixed_offset)
                    fixed_texts.append(text[fixed_offset[0] : fixed_offset[1]])

                entity_ann["offsets"] = fixed_offsets
                entity_ann["text"] = fixed_texts

            entity_ann["normalized"] = []
            source_example["entities"].append(entity_ann)

        for base_rel_annotation in brat_example["relations"]:
            if base_rel_annotation["type"].upper() not in _RELATION_TYPES:
                continue

            head_id = example_prefix + base_rel_annotation["head"]["ref_id"]
            tail_id = example_prefix + base_rel_annotation["tail"]["ref_id"]

            if head_id not in entity_ids or tail_id not in entity_ids:
                continue

            relation = {
                "id": example_prefix + base_rel_annotation["id"],
                "type": base_rel_annotation["type"],
                "arg1_id": head_id,
                "arg2_id": tail_id,
                "normalized": [],
            }

            source_example["relations"].append(relation)

        relation_id = len(brat_example["relations"]) + 10
        for base_co_reference in brat_example["equivalences"]:
            ref_ids = base_co_reference["ref_ids"]
            for i, arg1 in enumerate(ref_ids[:-1]):
                for arg2 in ref_ids[i + 1 :]:
                    if arg1 not in entity_ids or arg2 not in entity_ids:
                        continue

                    or_relation = {
                        "id": example_prefix + f"R{relation_id}",
                        "type": "OR",
                        "arg1_id": example_prefix + arg1,
                        "arg2_id": example_prefix + arg2,
                        "normalized": [],
                    }

                    source_example["relations"].append(or_relation)
                    relation_id += 1

        return source_example

    def _fix_entity_offsets(
        self, doc_text: str, entity_text: str, given_offsets: List[int]
    ) -> List[int]:
        """
        Fixes incorrect mention offsets by checking whether the given entity mention text can be
        found to the left or right of the given offsets by considering incrementally larger shifts.
        """
        left = given_offsets[0]
        right = given_offsets[1]

        # Some annotations contain whitespaces - we ignore them
        clean_entity_text = entity_text.strip()

        i = 0
        while i <= _MAX_OFFSET_CORRECTION:
            # Move mention window to the left
            if doc_text[left - i : right - i].strip() == clean_entity_text:
                return [left - i, left - i + len(clean_entity_text)]

            # Move mention window to the right
            elif doc_text[left + i : right + i].strip() == clean_entity_text:
                return [left + i, left + i + len(clean_entity_text)]

            i += 1

        # We can't find any better offsets
        return given_offsets

    def _get_texts_for_multiple_offsets(
        self, document_text: str, offsets: List[List[int]]
    ) -> List[str]:
        """
        Extracts the single text span for a given list of offsets.
        """
        texts = []
        for offset in offsets:
            texts.append(document_text[offset[0] : offset[1]])
        return texts


def parse_brat_file(txt_file: Path, annotation_file_suffixes: List[str] = None) -> Dict:
    """
    Parse a brat file into the schema defined below.
    `txt_file` should be the path to the brat '.txt' file you want to parse, e.g. 'data/1234.txt'
    Assumes that the annotations are contained in one or more of the corresponding '.a1', '.a2' or '.ann' files,
    e.g. 'data/1234.ann' or 'data/1234.a1' and 'data/1234.a2'.

    Schema of the parse:
       features = datasets.Features(
                {
                    "id": datasets.Value("string"),
                    "document_id": datasets.Value("string"),
                    "text": datasets.Value("string"),
                    "text_bound_annotations": [  # T line in brat, e.g. type or event trigger
                        {
                            "offsets": datasets.Sequence([datasets.Value("int32")]),
                            "text": datasets.Sequence(datasets.Value("string")),
                            "type": datasets.Value("string"),
                            "id": datasets.Value("string"),
                        }
                    ],
                    "events": [  # E line in brat
                        {
                            "trigger": datasets.Value(
                                "string"
                            ),  # refers to the text_bound_annotation of the trigger,
                            "id": datasets.Value("string"),
                            "type": datasets.Value("string"),
                            "arguments": datasets.Sequence(
                                {
                                    "role": datasets.Value("string"),
                                    "ref_id": datasets.Value("string"),
                                }
                            ),
                        }
                    ],
                    "relations": [  # R line in brat
                        {
                            "id": datasets.Value("string"),
                            "head": {
                                "ref_id": datasets.Value("string"),
                                "role": datasets.Value("string"),
                            },
                            "tail": {
                                "ref_id": datasets.Value("string"),
                                "role": datasets.Value("string"),
                            },
                            "type": datasets.Value("string"),
                        }
                    ],
                    "equivalences": [  # Equiv line in brat
                        {
                            "id": datasets.Value("string"),
                            "ref_ids": datasets.Sequence(datasets.Value("string")),
                        }
                    ],
                    "attributes": [  # M or A lines in brat
                        {
                            "id": datasets.Value("string"),
                            "type": datasets.Value("string"),
                            "ref_id": datasets.Value("string"),
                            "value": datasets.Value("string"),
                        }
                    ],
                    "normalizations": [  # N lines in brat
                        {
                            "id": datasets.Value("string"),
                            "type": datasets.Value("string"),
                            "ref_id": datasets.Value("string"),
                            "resource_name": datasets.Value(
                                "string"
                            ),  # Name of the resource, e.g. "Wikipedia"
                            "cuid": datasets.Value(
                                "string"
                            ),  # ID in the resource, e.g. 534366
                            "text": datasets.Value(
                                "string"
                            ),  # Human readable description/name of the entity, e.g. "Barack Obama"
                        }
                    ],
                },
            )
    """

    example = {}
    example["document_id"] = txt_file.with_suffix("").name
    with txt_file.open() as f:
        example["text"] = f.read()

    # If no specific suffixes of the to-be-read annotation files are given - take standard suffixes
    # for event extraction
    if annotation_file_suffixes is None:
        annotation_file_suffixes = [".a1", ".a2", ".ann"]

    if len(annotation_file_suffixes) == 0:
        raise AssertionError(
            "At least one suffix for the to-be-read annotation files should be given!"
        )

    ann_lines = []
    for suffix in annotation_file_suffixes:
        annotation_file = txt_file.with_suffix(suffix)
        try:
            with annotation_file.open() as f:
                ann_lines.extend(f.readlines())
        except Exception:
            continue

    example["text_bound_annotations"] = []
    example["events"] = []
    example["relations"] = []
    example["equivalences"] = []
    example["attributes"] = []
    example["normalizations"] = []

    prev_tb_annotation = None

    for line in ann_lines:
        orig_line = line
        line = line.strip()
        if not line:
            continue

        # If an (entity) annotation spans multiple lines, this will result in multiple
        # lines also in the annotation file
        if "\t" not in line and prev_tb_annotation is not None:
            prev_tb_annotation["text"][0] += "\n" + orig_line[:-1]
            continue

        if line.startswith("T"):  # Text bound
            ann = {}
            fields = line.split("\t")

            ann["id"] = fields[0]
            ann["text"] = [fields[2]]
            ann["type"] = fields[1].split()[0]
            ann["offsets"] = []
            span_str = remove_prefix(fields[1], (ann["type"] + " "))
            for span in span_str.split(";"):
                start, end = span.split()
                ann["offsets"].append([int(start), int(end)])

            example["text_bound_annotations"].append(ann)
            prev_tb_annotation = ann

        elif line.startswith("E"):
            ann = {}
            fields = line.split("\t")

            ann["id"] = fields[0]

            ann["type"], ann["trigger"] = fields[1].split()[0].split(":")

            ann["arguments"] = []
            for role_ref_id in fields[1].split()[1:]:
                argument = {
                    "role": (role_ref_id.split(":"))[0],
                    "ref_id": (role_ref_id.split(":"))[1],
                }
                ann["arguments"].append(argument)

            example["events"].append(ann)
            prev_tb_annotation = None

        elif line.startswith("R"):
            ann = {}
            fields = line.split("\t")

            ann["id"] = fields[0]
            ann["type"] = fields[1].split()[0]

            ann["head"] = {
                "role": fields[1].split()[1].split(":")[0],
                "ref_id": fields[1].split()[1].split(":")[1],
            }
            ann["tail"] = {
                "role": fields[1].split()[2].split(":")[0],
                "ref_id": fields[1].split()[2].split(":")[1],
            }

            example["relations"].append(ann)
            prev_tb_annotation = None

        # '*' seems to be the legacy way to mark equivalences,
        # but I couldn't find any info on the current way
        # this might have to be adapted dependent on the brat version
        # of the annotation
        elif line.startswith("*"):
            ann = {}
            fields = line.split("\t")

            ann["id"] = fields[0]
            ann["ref_ids"] = fields[1].split()[1:]

            example["equivalences"].append(ann)
            prev_tb_annotation = None

        elif line.startswith("A") or line.startswith("M"):
            ann = {}
            fields = line.split("\t")

            ann["id"] = fields[0]

            info = fields[1].split()
            ann["type"] = info[0]
            ann["ref_id"] = info[1]

            if len(info) > 2:
                ann["value"] = info[2]
            else:
                ann["value"] = ""

            example["attributes"].append(ann)
            prev_tb_annotation = None

        elif line.startswith("N"):
            ann = {}
            fields = line.split("\t")

            ann["id"] = fields[0]
            ann["text"] = fields[2]

            info = fields[1].split()

            ann["type"] = info[0]
            ann["ref_id"] = info[1]
            ann["resource_name"] = info[2].split(":")[0]
            ann["cuid"] = info[2].split(":")[1]

            example["normalizations"].append(ann)
            prev_tb_annotation = None

    return example