# 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