Datasets:

bigbio
/

bioinfer

Languages:

English

Multilinguality:

monolingual

Tags:

License:

Dataset card Viewer Files Files and versions Community

bioinfer / bioinfer.py

gabrielaltay

Support streaming (#1)

04f72d2 over 1 year ago

raw history blame contribute delete

No virus

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

	"""
	The authors present BioInfer (Bio Information Extraction Resource), a new public
	resource providing an annotated corpus of biomedical English. We describe an
	annotation scheme capturing named entities and their relationships along with a
	dependency analysis of sentence syntax. We further present ontologies defining
	the types of entities and relationships annotated in the corpus. Currently, the
	corpus contains 1100 sentences from abstracts of biomedical research articles
	annotated for relationships, named entities, as well as syntactic dependencies.
	"""

	import os
	import xml.etree.ElementTree as ET
	from typing import Dict, List, Tuple

	import datasets

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

	_LANGUAGES = ['English']
	_PUBMED = True
	_LOCAL = False
	_CITATION = """\
	@article{pyysalo2007bioinfer,
	title = {BioInfer: a corpus for information extraction in the biomedical domain},
	author = {
	Pyysalo, Sampo and Ginter, Filip and Heimonen, Juho and Bj{\"o}rne, Jari
	and Boberg, Jorma and J{\"a}rvinen, Jouni and Salakoski, Tapio
	},
	year = 2007,
	journal = {BMC bioinformatics},
	publisher = {BioMed Central},
	volume = 8,
	number = 1,
	pages = {1--24}
	}
	"""

	_DATASETNAME = "bioinfer"
	_DISPLAYNAME = "BioInfer"

	_DESCRIPTION = """\
	A corpus targeted at protein, gene, and RNA relationships which serves as a
	resource for the development of information extraction systems and their
	components such as parsers and domain analyzers. Currently, the corpus contains
	1100 sentences from abstracts of biomedical research articles annotated for
	relationships, named entities, as well as syntactic dependencies.
	"""

	_HOMEPAGE = "https://github.com/metalrt/ppi-dataset"

	_LICENSE = 'Creative Commons Attribution 2.0 Generic'

	_URLS = {
	_DATASETNAME: {
	"train": "https://github.com/metalrt/ppi-dataset/raw/master/csv_output/BioInfer-train.xml",
	"test": "https://github.com/metalrt/ppi-dataset/raw/master/csv_output/BioInfer-test.xml",
	}
	}

	_SUPPORTED_TASKS = [Tasks.RELATION_EXTRACTION, Tasks.NAMED_ENTITY_RECOGNITION]

	_SOURCE_VERSION = "1.0.0"
	_BIGBIO_VERSION = "1.0.0"


	class BioinferDataset(datasets.GeneratorBasedBuilder):
	"""
	1100 sentences from abstracts of biomedical research articles annotated
	for relationships, named entities, as well as syntactic dependencies.
	"""

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

	BUILDER_CONFIGS = [
	BigBioConfig(
	name="bioinfer_source",
	version=SOURCE_VERSION,
	description="BioInfer source schema",
	schema="source",
	subset_id="bioinfer",
	),
	BigBioConfig(
	name="bioinfer_bigbio_kb",
	version=BIGBIO_VERSION,
	description="BioInfer BigBio schema",
	schema="bigbio_kb",
	subset_id="bioinfer",
	),
	]

	DEFAULT_CONFIG_NAME = "bioinfer_source"

	def _info(self) -> datasets.DatasetInfo:

	if self.config.schema == "source":
	features = datasets.Features(
	{
	"document_id": datasets.Value("string"),
	"type": datasets.Value("string"),
	"text": datasets.Value("string"),
	"entities": [
	{
	"id": datasets.Value("string"),
	"offsets": [[datasets.Value("int32")]],
	"text": [datasets.Value("string")],
	"type": datasets.Value("string"),
	"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) -> List[datasets.SplitGenerator]:
	"""Returns SplitGenerators."""
	urls = _URLS[_DATASETNAME]
	data_dir = dl_manager.download(urls)
	return [
	datasets.SplitGenerator(
	name=datasets.Split.TRAIN,
	gen_kwargs={
	"filepath": data_dir["train"],
	"split": "train",
	},
	),
	datasets.SplitGenerator(
	name=datasets.Split.TEST,
	gen_kwargs={
	"filepath": data_dir["test"],
	"split": "test",
	},
	),
	]

	def _generate_examples(self, filepath, split: str) -> Tuple[int, Dict]:
	"""Yields examples as (key, example) tuples."""
	tree = ET.parse(filepath)
	root = tree.getroot()
	if self.config.schema == "source":
	for guid, sentence in enumerate(root.iter("sentence")):
	example = self._create_example(sentence)
	example["text"] = sentence.attrib["text"]
	example["type"] = "Sentence"
	yield guid, example

	elif self.config.schema == "bigbio_kb":
	for guid, sentence in enumerate(root.iter("sentence")):
	example = self._create_example(sentence)
	example["passages"] = [
	{
	"id": f"{sentence.attrib['id']}__text",
	"type": "Sentence",
	"text": [sentence.attrib["text"]],
	"offsets": [(0, len(sentence.attrib["text"]))],
	}
	]
	example["events"] = []
	example["coreferences"] = []
	example["id"] = guid
	yield guid, example

	def _create_example(self, sentence):
	example = {}
	example["document_id"] = sentence.attrib["id"]
	example["entities"] = []
	example["relations"] = []
	for tag in sentence:
	if tag.tag == "entity":
	example["entities"].append(self._add_entity(tag))
	elif tag.tag == "interaction":
	example["relations"].append(self._add_interaction(tag))
	else:
	raise ValueError(f"unknown tags: {tag.tag}")
	return example

	@staticmethod
	def _add_entity(entity):
	offsets = [
	[int(o) for o in offset.split("-")]
	for offset in entity.attrib["charOffset"].split(",")
	]
	# For multiple offsets, split entity text accordingly
	if len(offsets) > 1:
	text = []
	i = 0
	for start, end in offsets:
	chunk_len = end - start
	text.append(entity.attrib["text"][i : chunk_len + i])
	i += chunk_len
	while (
	i < len(entity.attrib["text"]) and entity.attrib["text"][i] == " "
	):
	i += 1
	else:
	text = [entity.attrib["text"]]
	return {
	"id": entity.attrib["id"],
	"offsets": offsets,
	"text": text,
	"type": entity.attrib["type"],
	"normalized": {},
	}

	@staticmethod
	def _add_interaction(interaction):
	return {
	"id": interaction.attrib["id"],
	"type": interaction.attrib["type"],
	"arg1_id": interaction.attrib["e1"],
	"arg2_id": interaction.attrib["e2"],
	"normalized": {},
	}