upload hubscripts/pico_extraction_hub.py to hub from bigbio repo

pico_extraction.py

@@ -0,0 +1,291 @@
+# 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.
+
+"""
+This dataset contains annotations for Participants, Interventions, and Outcomes (referred to as PICO task).
+For 423 sentences, annotations collected by 3 medical experts are available.
+To get the final annotations, we perform the majority voting.
+The script loads dataset in bigbio schema (using knowledgebase schema: schemas/kb) AND/OR source (default) schema
+"""
+import json
+from typing import Dict, List, Tuple, Union
+
+import datasets
+import numpy as np
+
+from .bigbiohub import kb_features
+from .bigbiohub import BigBioConfig
+from .bigbiohub import Tasks
+
+_LANGUAGES = ['English']
+_PUBMED = True
+_LOCAL = False
+_CITATION = """\
+@inproceedings{zlabinger-etal-2020-effective,
+    title = "Effective Crowd-Annotation of Participants, Interventions, and Outcomes in the Text of Clinical Trial Reports",
+    author = {Zlabinger, Markus  and
+      Sabou, Marta  and
+      Hofst{\"a}tter, Sebastian  and
+      Hanbury, Allan},
+    booktitle = "Findings of the Association for Computational Linguistics: EMNLP 2020",
+    month = nov,
+    year = "2020",
+    address = "Online",
+    publisher = "Association for Computational Linguistics",
+    url = "https://aclanthology.org/2020.findings-emnlp.274",
+    doi = "10.18653/v1/2020.findings-emnlp.274",
+    pages = "3064--3074",
+}
+"""
+
+_DATASETNAME = "pico_extraction"
+_DISPLAYNAME = "PICO Annotation"
+
+
+_DESCRIPTION = """\
+This dataset contains annotations for Participants, Interventions, and Outcomes (referred to as PICO task).
+For 423 sentences, annotations collected by 3 medical experts are available.
+To get the final annotations, we perform the majority voting.
+"""
+
+_HOMEPAGE = "https://github.com/Markus-Zlabinger/pico-annotation"
+
+_LICENSE = 'License information unavailable'
+
+_DATA_PATH = (
+    "https://raw.githubusercontent.com/Markus-Zlabinger/pico-annotation/master/data"
+)
+_URLS = {
+    _DATASETNAME: {
+        "sentence_file": f"{_DATA_PATH}/sentences.json",
+        "annotation_files": {
+            "intervention": f"{_DATA_PATH}/annotations/interventions_expert.json",
+            "outcome": f"{_DATA_PATH}/annotations/outcomes_expert.json",
+            "participant": f"{_DATA_PATH}/annotations/participants_expert.json",
+        },
+    }
+}
+
+_SUPPORTED_TASKS = [Tasks.NAMED_ENTITY_RECOGNITION]
+_SOURCE_VERSION = "1.0.0"
+_BIGBIO_VERSION = "1.0.0"
+
+
+def _pico_extraction_data_loader(
+    sentence_file: str, annotation_files: Dict[str, str]
+) -> Tuple[Dict[str, str], Dict[str, Dict[str, Dict[str, List[int]]]]]:
+    """Loads four files with PICO extraction dataset:
+    - one json file with sentences
+    - three json files with annotations for PIO
+    """
+    # load sentences
+    with open(sentence_file) as fp:
+        sentences = json.load(fp)
+
+    # load annotations
+    annotation_dict = {}
+    for annotation_type, _file in annotation_files.items():
+        with open(_file) as fp:
+            annotations = json.load(fp)
+            annotation_dict[annotation_type] = annotations
+
+    return sentences, annotation_dict
+
+
+def _get_entities_pico(
+    annotation_dict: Dict[str, Dict[str, Dict[str, List[int]]]],
+    sentence: str,
+    sentence_id: str,
+) -> List[Dict[str, Union[int, str]]]:
+    """extract entities from sentences using annotation_dict"""
+
+    def _partition(alist, indices):
+        return [alist[i:j] for i, j in zip([0] + indices, indices + [None])]
+
+    ents = []
+    for annotation_type, annotations in annotation_dict.items():
+        # get indices from three annotators by majority voting
+        indices = np.where(
+            np.round(np.mean(annotations[sentence_id]["annotations"], axis=0)) == 1
+        )[0]
+
+        if len(indices) > 0:  # if annotations exist for this sentence
+            split_indices = []
+            # if there are two annotations of one type in one sentence
+            for item_index, item in enumerate(indices):
+                if item_index + 1 == len(indices):
+                    break
+                if indices[item_index] + 1 != indices[item_index + 1]:
+                    split_indices.append(item_index + 1)
+            multiple_indices = _partition(indices, split_indices)
+
+            for _indices in multiple_indices:
+
+                annotation_text = " ".join([sentence.split()[ind] for ind in _indices])
+
+                char_start = sentence.find(annotation_text)
+                char_end = char_start + len(annotation_text)
+
+                ent = {
+                    "annotation_text": annotation_text,
+                    "annotation_type": annotation_type,
+                    "char_start": char_start,
+                    "char_end": char_end,
+                }
+
+                ents.append(ent)
+    return ents
+
+
+class PicoExtractionDataset(datasets.GeneratorBasedBuilder):
+    """PICO Extraction dataset with annotations for
+    Participants, Interventions, and Outcomes."""
+
+    SOURCE_VERSION = datasets.Version(_SOURCE_VERSION)
+    BIGBIO_VERSION = datasets.Version(_BIGBIO_VERSION)
+
+    BUILDER_CONFIGS = [
+        BigBioConfig(
+            name="pico_extraction_source",
+            version=SOURCE_VERSION,
+            description="pico_extraction source schema",
+            schema="source",
+            subset_id="pico_extraction",
+        ),
+        BigBioConfig(
+            name="pico_extraction_bigbio_kb",
+            version=BIGBIO_VERSION,
+            description="pico_extraction BigBio schema",
+            schema="bigbio_kb",
+            subset_id="pico_extraction",
+        ),
+    ]
+
+    DEFAULT_CONFIG_NAME = "pico_extraction_source"
+
+    def _info(self) -> datasets.DatasetInfo:
+
+        if self.config.schema == "source":
+            features = datasets.Features(
+                {
+                    "doc_id": datasets.Value("string"),
+                    "text": datasets.Value("string"),
+                    "entities": [
+                        {
+                            "text": datasets.Value("string"),
+                            "type": datasets.Value("string"),
+                            "start": datasets.Value("int64"),
+                            "end": datasets.Value("int64"),
+                        }
+                    ],
+                }
+            )
+
+        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) -> List[datasets.SplitGenerator]:
+        """Returns SplitGenerators."""
+
+        urls = _URLS[_DATASETNAME]
+        data_dir = dl_manager.download_and_extract(urls)
+
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={
+                    "split": "train",
+                    "sentence_file": data_dir["sentence_file"],
+                    "annotation_files": data_dir["annotation_files"],
+                },
+            ),
+        ]
+
+    def _generate_examples(self, split, sentence_file, annotation_files):
+        """Yields examples as (key, example) tuples."""
+
+        sentences, annotation_dict = _pico_extraction_data_loader(
+            sentence_file=sentence_file, annotation_files=annotation_files
+        )
+
+        if self.config.schema == "source":
+            for uid, sentence_tuple in enumerate(sentences.items()):
+                sentence_id, sentence = sentence_tuple
+                ents = _get_entities_pico(annotation_dict, sentence, sentence_id)
+
+                data = {
+                    "doc_id": sentence_id,
+                    "text": sentence,
+                    "entities": [
+                        {
+                            "text": ent["annotation_text"],
+                            "type": ent["annotation_type"],
+                            "start": ent["char_start"],
+                            "end": ent["char_end"],
+                        }
+                        for ent in ents
+                    ],
+                }
+                yield uid, data
+
+        elif self.config.schema == "bigbio_kb":
+            uid = 0
+            for id_, sentence_tuple in enumerate(sentences.items()):
+                if id_ < 2:
+                    continue
+                sentence_id, sentence = sentence_tuple
+                ents = _get_entities_pico(annotation_dict, sentence, sentence_id)
+
+                data = {
+                    "id": str(uid),
+                    "document_id": sentence_id,
+                    "passages": [],
+                    "entities": [],
+                    "relations": [],
+                    "events": [],
+                    "coreferences": [],
+                }
+                uid += 1
+
+                data["passages"] = [
+                    {
+                        "id": str(uid),
+                        "type": "sentence",
+                        "text": [sentence],
+                        "offsets": [[0, len(sentence)]],
+                    }
+                ]
+                uid += 1
+
+                for ent in ents:
+                    entity = {
+                        "id": uid,
+                        "type": ent["annotation_type"],
+                        "text": [ent["annotation_text"]],
+                        "offsets": [[ent["char_start"], ent["char_end"]]],
+                        "normalized": [],
+                    }
+                    data["entities"].append(entity)
+                    uid += 1
+
+                yield uid, data