Datasets:

bigbio
/

mirna

Languages:

English

Multilinguality:

monolingual

Tags:

License:

Dataset card Viewer Files Files and versions Community

mirna / mirna.py

gabrielaltay

upload hubscripts/mirna_hub.py to hub from bigbio repo

90d8750 over 1 year ago

raw history blame contribute delete

No virus

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

	import xml.etree.ElementTree as ET
	from typing import Dict, Iterator, 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{Bagewadi2014,
	author={Bagewadi, Shweta
	and Bobi{\'{c}}, Tamara
	and Hofmann-Apitius, Martin
	and Fluck, Juliane
	and Klinger, Roman},
	title={Detecting miRNA Mentions and Relations in Biomedical Literature},
	journal={F1000Research},
	year={2014},
	month={Aug},
	day={28},
	publisher={F1000Research},
	volume={3},
	pages={205-205},
	keywords={MicroRNAs; corpus; prediction algorithms},
	abstract={
	INTRODUCTION: MicroRNAs (miRNAs) have demonstrated their potential as post-transcriptional
	gene expression regulators, participating in a wide spectrum of regulatory events such as
	apoptosis, differentiation, and stress response. Apart from the role of miRNAs in normal
	physiology, their dysregulation is implicated in a vast array of diseases. Dissection of
	miRNA-related associations are valuable for contemplating their mechanism in diseases,
	leading to the discovery of novel miRNAs for disease prognosis, diagnosis, and therapy.
	MOTIVATION: Apart from databases and prediction tools, miRNA-related information is largely
	available as unstructured text. Manual retrieval of these associations can be labor-intensive
	due to steadily growing number of publications. Additionally, most of the published miRNA
	entity recognition methods are keyword based, further subjected to manual inspection for
	retrieval of relations. Despite the fact that several databases host miRNA-associations
	derived from text, lower sensitivity and lack of published details for miRNA entity
	recognition and associated relations identification has motivated the need for developing
	comprehensive methods that are freely available for the scientific community. Additionally,
	the lack of a standard corpus for miRNA-relations has caused difficulty in evaluating the
	available systems. We propose methods to automatically extract mentions of miRNAs, species,
	genes/proteins, disease, and relations from scientific literature. Our generated corpora,
	along with dictionaries, and miRNA regular expression are freely available for academic
	purposes. To our knowledge, these resources are the most comprehensive developed so far.
	RESULTS: The identification of specific miRNA mentions reaches a recall of 0.94 and
	precision of 0.93. Extraction of miRNA-disease and miRNA-gene relations lead to an
	F1 score of up to 0.76. A comparison of the information extracted by our approach to
	the databases miR2Disease and miRSel for the extraction of Alzheimer's disease
	related relations shows the capability of our proposed methods in identifying correct
	relations with improved sensitivity. The published resources and described methods can
	help the researchers for maximal retrieval of miRNA-relations and generation of
	miRNA-regulatory networks. AVAILABILITY: The training and test corpora, annotation
	guidelines, developed dictionaries, and supplementary files are available at
	http://www.scai.fraunhofer.de/mirna-corpora.html.
	},
	note={26535109[pmid]},
	note={PMC4602280[pmcid]},
	issn={2046-1402},
	url={https://pubmed.ncbi.nlm.nih.gov/26535109},
	language={eng}
	}
	"""

	_DATASETNAME = "mirna"
	_DISPLAYNAME = "miRNA"

	_DESCRIPTION = """\
	The corpus consists of 301 Medline citations. The documents were screened for
	mentions of miRNA in the abstract text. Gene, disease and miRNA entities were manually
	annotated. The corpus comprises of two separate files, a train and a test set, coming
	from 201 and 100 documents respectively.
	"""

	_HOMEPAGE = "https://www.scai.fraunhofer.de/en/business-research-areas/bioinformatics/downloads/download-mirna-test-corpus.html"

	_LICENSE = 'Creative Commons Attribution Non Commercial 3.0 Unported'

	_BASE = "https://www.scai.fraunhofer.de/content/dam/scai/de/downloads/bioinformatik/miRNA/miRNA-"

	_URLs = {
	"source": {
	"train": _BASE + "Train-Corpus.xml",
	"test": _BASE + "Test-Corpus.xml",
	},
	"bigbio_kb": {
	"train": _BASE + "Train-Corpus.xml",
	"test": _BASE + "Test-Corpus.xml",
	},
	}

	_SUPPORTED_TASKS = [Tasks.NAMED_ENTITY_RECOGNITION, Tasks.NAMED_ENTITY_DISAMBIGUATION]
	_SOURCE_VERSION = "1.0.0"
	_BIGBIO_VERSION = "1.0.0"


	class miRNADataset(datasets.GeneratorBasedBuilder):
	"""mirna"""

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

	BUILDER_CONFIGS = [
	BigBioConfig(
	name="mirna_source",
	version=SOURCE_VERSION,
	description="mirna source schema",
	schema="source",
	subset_id="mirna",
	),
	BigBioConfig(
	name="mirna_bigbio_kb",
	version=BIGBIO_VERSION,
	description="mirna BigBio schema",
	schema="bigbio_kb",
	subset_id="mirna",
	),
	]

	DEFAULT_CONFIG_NAME = "mirna_source"

	def _info(self):

	if self.config.schema == "source":

	features = datasets.Features(
	{
	"passages": [
	{
	"document_id": datasets.Value("string"),
	"type": datasets.Value("string"),
	"text": datasets.Value("string"),
	"offset": datasets.Value("int32"),
	"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"),
	}
	],
	}
	],
	}
	]
	}
	)

	elif self.config.schema == "bigbio_kb":
	features = kb_features

	return datasets.DatasetInfo(
	description=_DESCRIPTION,
	features=features,
	supervised_keys=None,
	homepage=_HOMEPAGE,
	license=str(_LICENSE),
	citation=_CITATION,
	)

	def _split_generators(self, dl_manager):
	"""Returns SplitGenerators."""

	my_urls = _URLs[self.config.schema]

	path_xml_train = dl_manager.download(my_urls["train"])
	path_xml_test = dl_manager.download(my_urls["test"])

	return [
	datasets.SplitGenerator(
	name=datasets.Split.TRAIN,
	# These kwargs will be passed to _generate_examples
	gen_kwargs={
	"filepath": path_xml_train,
	"split": "train",
	},
	),
	datasets.SplitGenerator(
	name=datasets.Split.TEST,
	# These kwargs will be passed to _generate_examples
	gen_kwargs={
	"filepath": path_xml_test,
	"split": "test",
	},
	),
	]

	def _get_passages_and_entities(self, d) -> Tuple[List[Dict], List[List[Dict]]]:

	sentences: List[Dict] = []
	entities: List[List[Dict]] = []
	relations: List[List[Dict]] = []

	text_total_length = 0

	po_start = 0

	# Get sentences of the document
	for _, s in enumerate(d):

	# annotation used only for document indexing
	if s.attrib["text"] is None or len(s.attrib["text"]) <= 0:
	continue

	# annotation used only for document indexing
	if len(s) <= 0:
	continue

	text_total_length += len(s.attrib["text"]) + 1

	po_end = po_start + len(s.attrib["text"])

	start = po_start

	dp = {
	"text": s.attrib["text"],
	"type": "title" if ".s0" in s.attrib["id"] else "abstract",
	"offsets": [(po_start, po_end)],
	"offset": 0, # original offset
	}

	po_start = po_end + 1

	sentences.append(dp)

	pe = [] # entities
	re = [] # relations

	# For each entity
	for a in s:

	# If correspond to a entity
	if a.tag == "entity":

	length = len(a.attrib["text"])

	if a.attrib["text"] is None or length <= 0:
	continue

	# no in-text annotation: only for document indexing
	if a.attrib["type"] in ["MeSH_Indexing_Chemical", "OTHER"]:
	continue

	startOffset, endOffset = a.attrib["charOffset"].split("-")
	startOffset, endOffset = int(startOffset), int(endOffset)

	pe.append(
	{
	"id": a.attrib["id"],
	"type": a.attrib["type"],
	"text": (a.attrib["text"],),
	"offsets": [(start + startOffset, start + endOffset + 1)],
	"normalized": [
	{"db_name": "miRNA-corpus", "db_id": a.attrib["id"]}
	],
	}
	)

	# If correspond to relation pair
	elif a.tag == "pair":

	re.append(
	{
	"id": a.attrib["id"],
	"type": a.attrib["type"],
	"arg1_id": a.attrib["e1"],
	"arg2_id": a.attrib["e2"],
	"normalized": [],
	}
	)

	entities.append(pe)
	relations.append(re)

	return sentences, entities, relations

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

	reader = ET.fromstring(open(str(filepath), "r").read())

	if self.config.schema == "source":

	for uid, doc in enumerate(reader):

	(
	sentences,
	sentences_entities,
	relations,
	) = self._get_passages_and_entities(doc)

	if (
	len(sentences) < 1
	or len(sentences_entities) < 1
	or len(sentences_entities) != len(sentences)
	):
	continue

	for p, pe, re in zip(sentences, sentences_entities, relations):

	p.pop("offsets") # BioC has only start for passages offsets

	p["document_id"] = doc.attrib["id"]
	p["entities"] = pe # BioC has per passage entities

	yield uid, {"passages": sentences}

	elif self.config.schema == "bigbio_kb":

	uid = 0

	for idx, doc in enumerate(reader):

	(
	sentences,
	sentences_entities,
	relations,
	) = self._get_passages_and_entities(doc)

	if (
	len(sentences) < 1
	or len(sentences_entities) < 1
	or len(sentences_entities) != len(sentences)
	):
	continue

	# global id
	uid += 1

	# unpack per-sentence entities
	entities = [e for pe in sentences_entities for e in pe]

	for p in sentences:
	p.pop("offset") # drop original offset
	p["text"] = (p["text"],) # text in sentence is Sequence
	p["id"] = uid
	uid += 1

	for e in entities:
	e["id"] = uid
	uid += 1

	# unpack per-sentence relations
	relations = [r for re in relations for r in re]

	for r in relations:
	r["id"] = uid
	uid += 1

	yield idx, {
	"id": uid,
	"document_id": doc.attrib["id"],
	"passages": sentences,
	"entities": entities,
	"events": [],
	"coreferences": [],
	"relations": relations,
	}