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

"""
The "Psychiatric Treatment Adverse Reactions" (PsyTAR) dataset contains 891 drugs
reviews posted by patients on "askapatient.com", about the effectiveness and adverse
drug events associated with Zoloft, Lexapro, Cymbalta, and Effexor XR.

For each drug review, patient demographics, duration of treatment, and satisfaction
with the drugs were reported.

This dataset can be used for:

1. (multi-label) sentence classification, across 5 labels:
    Adverse Drug Reaction (ADR)
    Withdrawal Symptoms (WDs)
    Sign/Symptoms/Illness (SSIs)
    Drug Indications (DIs)
    Drug Effectiveness (EF)
    Drug Infectiveness (INF)
    and Others (not applicable)

2. Recognition of 5 different types of entity:
    ADRs (4813 mentions)
    WDs (590 mentions)
    SSIs (1219 mentions)
    DIs (792 mentions)

In the source schema, systematic annotation with UMLS and SNOMED-CT concepts are provided.
"""

import re
from dataclasses import dataclass
from pathlib import Path
from typing import Dict, List, Tuple

import datasets
import pandas as pd

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

_LANGUAGES = ['English']
_PUBMED = False
_LOCAL = True
_CITATION = """\
@article{Zolnoori2019,
  author    = {Maryam Zolnoori and
               Kin Wah Fung and
               Timothy B. Patrick and
               Paul Fontelo and
               Hadi Kharrazi and
               Anthony Faiola and
               Yi Shuan Shirley Wu and
               Christina E. Eldredge and
               Jake Luo and
               Mike Conway and
               Jiaxi Zhu and
               Soo Kyung Park and
               Kelly Xu and
               Hamideh Moayyed and
               Somaieh Goudarzvand},
  title     = {A systematic approach for developing a corpus of patient \
               reported adverse drug events: A case study for {SSRI} and {SNRI} medications},
  journal   = {Journal of Biomedical Informatics},
  volume    = {90},
  year      = {2019},
  url       = {https://doi.org/10.1016/j.jbi.2018.12.005},
  doi       = {10.1016/j.jbi.2018.12.005},
}
"""

_DATASETNAME = "psytar"
_DISPLAYNAME = "PsyTAR"

_DESCRIPTION = """\
The "Psychiatric Treatment Adverse Reactions" (PsyTAR) dataset contains 891 drugs
reviews posted by patients on "askapatient.com", about the effectiveness and adverse
drug events associated with Zoloft, Lexapro, Cymbalta, and Effexor XR.

This dataset can be used for (multi-label) sentence classification of Adverse Drug
Reaction (ADR), Withdrawal Symptoms (WDs), Sign/Symptoms/Illness (SSIs), Drug
Indications (DIs), Drug Effectiveness (EF), Drug Infectiveness (INF) and Others, as well
as for recognition of 5 different types of named entity (in the categories ADRs, WDs,
SSIs and DIs)
"""

_HOMEPAGE = "https://www.askapatient.com/research/pharmacovigilance/corpus-ades-psychiatric-medications.asp"

_LICENSE = 'Creative Commons Attribution 4.0 International'

_SUPPORTED_TASKS = [Tasks.NAMED_ENTITY_RECOGNITION, Tasks.TEXT_CLASSIFICATION]

_SOURCE_VERSION = "1.0.0"
_BIGBIO_VERSION = "1.0.0"


@dataclass
class PsyTARBigBioConfig(BigBioConfig):
    schema: str = "source"
    name: str = "psytar_source"
    version: datasets.Version = _SOURCE_VERSION
    description: str = "PsyTAR source schema"
    subset_id: str = "psytar"


class PsyTARDataset(datasets.GeneratorBasedBuilder):
    """The PsyTAR dataset contains patient's reviews on the effectiveness and adverse
    drug events associated with Zoloft, Lexapro, Cymbalta, and Effexor XR."""

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

    BUILDER_CONFIGS = [
        PsyTARBigBioConfig(
            name="psytar_source",
            version=SOURCE_VERSION,
            description="PsyTAR source schema",
            schema="source",
            subset_id="psytar",
        ),
        PsyTARBigBioConfig(
            name="psytar_bigbio_kb",
            version=BIGBIO_VERSION,
            description="PsyTAR BigBio KB schema",
            schema="bigbio_kb",
            subset_id="psytar",
        ),
        PsyTARBigBioConfig(
            name="psytar_bigbio_text",
            version=BIGBIO_VERSION,
            description="PsyTAR BigBio text classification schema",
            schema="bigbio_text",
            subset_id="psytar",
        ),
    ]

    BUILDER_CONFIG_CLASS = PsyTARBigBioConfig

    DEFAULT_CONFIG_NAME = "psytar_source"

    def _info(self) -> datasets.DatasetInfo:

        if self.config.schema == "source":
            features = datasets.Features(
                {
                    "id": datasets.Value("string"),
                    "doc_id": datasets.Value("string"),
                    "disorder": datasets.Value("string"),
                    "side_effect": datasets.Value("string"),
                    "comment": datasets.Value("string"),
                    "gender": datasets.Value("string"),
                    "age": datasets.Value("int32"),
                    "dosage_duration": datasets.Value("string"),
                    "date": datasets.Value("string"),
                    "category": datasets.Value("string"),
                    "sentences": [
                        {
                            "text": datasets.Value("string"),
                            "label": datasets.Sequence([datasets.Value("string")]),
                            "findings": datasets.Value("string"),
                            "others": datasets.Value("string"),
                            "rating": datasets.Value("string"),
                            "category": datasets.Value("string"),
                            "entities": [
                                {
                                    "text": datasets.Value("string"),
                                    "type": datasets.Value("string"),
                                    "mild": datasets.Value("string"),
                                    "moderate": datasets.Value("string"),
                                    "severe": datasets.Value("string"),
                                    "persistent": datasets.Value("string"),
                                    "non_persistent": datasets.Value("string"),
                                    "body_site": datasets.Value("string"),
                                    "rating": datasets.Value("string"),
                                    "drug": datasets.Value("string"),
                                    "class": datasets.Value("string"),
                                    "entity_type": datasets.Value("string"),
                                    "UMLS": datasets.Sequence(
                                        [datasets.Value("string")]
                                    ),
                                    "SNOMED": datasets.Sequence(
                                        [datasets.Value("string")]
                                    ),
                                }
                            ],
                        }
                    ],
                }
            )
        elif self.config.schema == "bigbio_kb":
            features = kb_features
        elif self.config.schema == "bigbio_text":
            features = text_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."""
        if self.config.data_dir is None:
            raise ValueError(
                "This is a local dataset. Please pass the data_dir kwarg to load_dataset."
            )
        else:
            data_dir = self.config.data_dir

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

    def _extract_labels(self, row):
        label = [
            "ADR" * row.ADR,
            "WD" * row.WD,
            "EF" * row.EF,
            "INF" * row.INF,
            "SSI" * row.SSI,
            "DI" * row.DI,
            "Others" * row.others,
        ]
        label = [_l for _l in label if _l != ""]
        return label

    def _columns_to_list(self, row, sheet="ADR"):
        annotations = []
        for i in range(30 if sheet == "ADR" else 10):
            annotations.append(row[f"{sheet}{i + 1}"])
        annotations = [a for a in annotations if not pd.isna(a)]
        return annotations

    def _columns_to_bigbio_kb(self, row, sheet="ADR"):
        annotations = []
        for i in range(30 if sheet == "ADR" else 10):
            annotation = row[f"{sheet}{i + 1}"]
            if not pd.isna(annotation):
                start_index = row.sentences.lower().find(annotation.lower())
                if start_index != -1:
                    end_index = start_index + len(annotation)
                    entity = {
                        "id": f"T{i+1}",
                        "offsets": [[start_index, end_index]],
                        "text": [annotation],
                        "type": sheet,
                    }

                    annotations.append(entity)
        return annotations

    def _standards_columns_to_list(self, row, standard="UMLS"):
        standards = {"UMLS": ["UMLS1", "UMLS2"], "SNOMED": ["SNOMED-CT", "SNOMED-CT.1"]}
        _out_list = []
        for s in standards[standard]:
            _out_list.append(row[s])
        _out_list = [a for a in _out_list if not pd.isna(a)]
        return _out_list

    def _read_sentence_xlsx(self, filepath: Path) -> pd.DataFrame:
        sentence_df = pd.read_excel(
            filepath,
            sheet_name="Sentence_Labeling",
            dtype={"drug_id": str, "sentences": str},
        )

        sentence_df = sentence_df.dropna(subset=["sentences"])
        sentence_df = sentence_df.loc[
            sentence_df.sentences.apply(lambda x: len(x.strip())) > 0
        ]
        sentence_df = sentence_df.fillna(0)

        sentence_df[["ADR", "WD", "EF", "INF", "SSI", "DI"]] = (
            sentence_df[["ADR", "WD", "EF", "INF", "SSI", "DI"]]
            .replace(re.compile("[!* ]+"), 1)
            .astype(int)
        )

        sentence_df["sentence_index"] = sentence_df["sentence_index"].astype("int32")
        sentence_df["drug_id"] = sentence_df["drug_id"].astype("str")

        return sentence_df

    def _read_samples_xlsx(self, filepath: Path) -> pd.DataFrame:
        samples_df = pd.read_excel(
            filepath, sheet_name="Sample", dtype={"drug_id": str}
        )
        samples_df["age"] = samples_df["age"].fillna(0).astype(int)
        samples_df["drug_id"] = samples_df["drug_id"].astype("str")

        return samples_df

    def _read_identified_xlsx_to_bigbio_kb(self, filepath: Path) -> Dict:
        sheet_names = ["ADR", "WD", "SSI", "DI"]
        identified_entities = {}

        for sheet in sheet_names:
            identified_entities[sheet] = pd.read_excel(
                filepath, sheet_name=sheet + "_Identified"
            )
            identified_entities[sheet]["bigbio_kb"] = identified_entities[sheet].apply(
                lambda x: self._columns_to_bigbio_kb(x, sheet), axis=1
            )

        return identified_entities

    TYPE_TO_COLNAME = {"ADR": "ADRs", "DI": "DIs", "SSI": "SSI", "WD": "WDs"}

    def _identified_mapped_xlsx_to_df(self, filepath: Path) -> pd.DataFrame:
        sheet_names_mapped = [
            ["ADR_Mapped", "ADR"],
            ["WD-Mapped ", "WD"],
            ["SSI_Mapped", "SSI"],
            ["DI_Mapped", "DI"],
        ]

        _mappings = []

        # Read the specific XLSX sheet with _Mapped annotations
        for sheet, sheet_short in sheet_names_mapped:
            _df_mapping = pd.read_excel(filepath, sheet_name=sheet)

            # Correcting column names
            if sheet_short in ["WD"]:
                _df_mapping = _df_mapping.rename(
                    columns={"sentence_id": "sentence_index"}
                )

            # Changing column names to allow concatenation
            _df_mapping = _df_mapping.rename(
                columns={self.TYPE_TO_COLNAME[sheet_short]: "entity"}
            )

            # Putting UMLS and SNOMED annotations in a single column
            _df_mapping["UMLS"] = _df_mapping.apply(
                lambda x: self._standards_columns_to_list(x), axis=1
            )
            _df_mapping["SNOMED"] = _df_mapping.apply(
                lambda x: self._standards_columns_to_list(x, standard="SNOMED"), axis=1
            )

            _mappings.append(_df_mapping)

        df_mappings = pd.concat(_mappings).fillna(0)
        df_mappings["sentence_index"] = df_mappings["sentence_index"].astype("int32")
        df_mappings["drug_id"] = df_mappings["drug_id"].astype("str")

        return df_mappings

    def _convert_xlsx_to_source(self, filepath: Path) -> Dict:
        # Read XLSX files
        df_sentences = self._read_sentence_xlsx(filepath)
        df_sentences["label"] = df_sentences.apply(
            lambda x: self._extract_labels(x), axis=1
        )
        df_mappings = self._identified_mapped_xlsx_to_df(filepath)
        df_samples = self._read_samples_xlsx(filepath)

        # Configure indices
        df_samples = df_samples.set_index("drug_id").sort_index()
        df_sentences = df_sentences.set_index(
            ["drug_id", "sentence_index"]
        ).sort_index()
        df_mappings = df_mappings.set_index(["drug_id", "sentence_index"]).sort_index()

        # Iterate over samples
        for sample_row_id, sample in df_samples.iterrows():
            sentences = []
            try:
                df_sentence_selection = df_sentences.loc[sample_row_id]

                # Iterate over sentences
                for sentence_row_id, sentence in df_sentence_selection.iterrows():
                    entities = []
                    try:
                        df_mapped_selection = df_mappings.loc[
                            sample_row_id, sentence_row_id
                        ]

                        # Iterate over entities per sentence
                        for mapped_row_id, row in df_mapped_selection.iterrows():
                            entities.append(
                                {
                                    "text": row["entity"],
                                    "UMLS": row.UMLS,
                                    "SNOMED": row.SNOMED,
                                    "entity_type": row.entity_type,
                                    "type": row.type,
                                    "class": row["class"],
                                    "drug": row.drug,
                                    "rating": row.rating,
                                    "body_site": row["body-site"],
                                    "non_persistent": row["not-persistent"],
                                    "persistent": row["persistent"],
                                    "severe": row.severe,
                                    "moderate": row.moderate,
                                    "mild": row.mild,
                                }
                            )
                    except KeyError:
                        pass

                    sentences.append(
                        {
                            "text": sentence.sentences,
                            "entities": entities,
                            "label": sentence.label,
                            "findings": sentence.Findings,
                            "others": sentence.others,
                            "rating": sentence.rating,
                            "category": sentence.category,
                        }
                    )
            except KeyError:
                pass

            example = {
                "id": sample_row_id,
                "doc_id": sample_row_id,
                "disorder": sample.disorder,
                "side_effect": sample["side-effect"],
                "comment": sample.comment,
                "gender": sample.gender,
                "age": sample.age,
                "dosage_duration": sample.dosage_duration,
                "date": str(sample.date),
                "category": sample.category,
                "sentences": sentences,
            }
            yield example

    def _convert_xlsx_to_bigbio_kb(self, filepath: Path) -> Dict:
        bigbio_kb = self._read_identified_xlsx_to_bigbio_kb(filepath)

        i_doc = 0
        for _, df in bigbio_kb.items():
            for _, row in df.iterrows():
                text = row.sentences
                entities = row["bigbio_kb"]
                doc_id = f"{row['drug_id']}_{row['sentence_index']}_{i_doc}"

                if len(entities) != 0:
                    example = parsing.brat_parse_to_bigbio_kb(
                        {
                            "document_id": doc_id,
                            "text": text,
                            "text_bound_annotations": entities,
                            "normalizations": [],
                            "events": [],
                            "relations": [],
                            "equivalences": [],
                            "attributes": [],
                        },
                    )
                    example["id"] = i_doc
                    i_doc += 1
                    yield example

    def _convert_xlsx_to_bigbio_text(self, filepath: Path) -> Dict:
        df = self._read_sentence_xlsx(filepath)
        df["label"] = df.apply(lambda x: self._extract_labels(x), axis=1)

        for idx, row in df.iterrows():
            example = {
                "id": idx,
                "document_id": f"{row['drug_id']}_{row['sentence_index']}",
                "text": row["label"],
                "labels": row["category"],
            }
            yield example

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

        if self.config.schema == "source":
            examples = self._convert_xlsx_to_source(filepath)

        elif self.config.schema == "bigbio_kb":
            examples = self._convert_xlsx_to_bigbio_kb(filepath)

        elif self.config.schema == "bigbio_text":
            examples = self._convert_xlsx_to_bigbio_text(filepath)

        for idx, example in enumerate(examples):
            yield idx, example