Datasets:

bigbio
/

pico_extraction

Languages:

English

Multilinguality:

monolingual

Tags:

License:

Dataset card Viewer Files Files and versions Community

pico_extraction / pico_extraction.py

gabrielaltay

upload hubscripts/pico_extraction_hub.py to hub from bigbio repo

8e78222 over 1 year ago

raw history blame contribute delete

No virus

10.2 kB

	# 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