|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
import itertools |
|
import os |
|
import uuid |
|
import xml.etree.ElementTree as ET |
|
from typing import List |
|
|
|
import datasets |
|
from numpy import int32 |
|
|
|
from .bigbiohub import kb_features |
|
from .bigbiohub import BigBioConfig |
|
from .bigbiohub import Tasks |
|
|
|
_LANGUAGES = ['English'] |
|
_PUBMED = True |
|
_LOCAL = False |
|
_CITATION = """\ |
|
@ARTICLE{Furlong2008, |
|
author = {Laura I Furlong and Holger Dach and Martin Hofmann-Apitius and Ferran Sanz}, |
|
title = {OSIRISv1.2: a named entity recognition system for sequence variants |
|
of genes in biomedical literature.}, |
|
journal = {BMC Bioinformatics}, |
|
year = {2008}, |
|
volume = {9}, |
|
pages = {84}, |
|
doi = {10.1186/1471-2105-9-84}, |
|
pii = {1471-2105-9-84}, |
|
pmid = {18251998}, |
|
timestamp = {2013.01.15}, |
|
url = {http://dx.doi.org/10.1186/1471-2105-9-84} |
|
} |
|
""" |
|
|
|
_DATASETNAME = "osiris" |
|
_DISPLAYNAME = "OSIRIS" |
|
|
|
_DESCRIPTION = """\ |
|
The OSIRIS corpus is a set of MEDLINE abstracts manually annotated |
|
with human variation mentions. The corpus is distributed under the terms |
|
of the Creative Commons Attribution License |
|
Creative Commons Attribution 3.0 Unported License, |
|
which permits unrestricted use, distribution, and reproduction in any medium, |
|
provided the original work is properly cited (Furlong et al, BMC Bioinformatics 2008, 9:84). |
|
""" |
|
|
|
_HOMEPAGE = "https://sites.google.com/site/laurafurlongweb/databases-and-tools/corpora/" |
|
|
|
|
|
_LICENSE = 'Creative Commons Attribution 3.0 Unported' |
|
|
|
_URLS = { |
|
_DATASETNAME: [ |
|
"https://github.com/rockt/SETH/blob/master/resources/OSIRIS/corpus.xml?raw=true " |
|
] |
|
} |
|
|
|
_SUPPORTED_TASKS = [Tasks.NAMED_ENTITY_RECOGNITION, Tasks.NAMED_ENTITY_DISAMBIGUATION] |
|
|
|
|
|
_SOURCE_VERSION = "1.2.0" |
|
|
|
_BIGBIO_VERSION = "1.0.0" |
|
|
|
|
|
class Osiris(datasets.GeneratorBasedBuilder): |
|
""" |
|
The OSIRIS corpus is a set of MEDLINE abstracts manually annotated |
|
with human variation mentions. |
|
""" |
|
|
|
SOURCE_VERSION = datasets.Version(_SOURCE_VERSION) |
|
BIGBIO_VERSION = datasets.Version(_BIGBIO_VERSION) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
BUILDER_CONFIGS = [ |
|
BigBioConfig( |
|
name="osiris_source", |
|
version=SOURCE_VERSION, |
|
description="osiris source schema", |
|
schema="source", |
|
subset_id="osiris", |
|
), |
|
BigBioConfig( |
|
name="osiris_bigbio_kb", |
|
version=BIGBIO_VERSION, |
|
description="osiris BigBio schema", |
|
schema="bigbio_kb", |
|
subset_id="osiris", |
|
), |
|
] |
|
|
|
DEFAULT_CONFIG_NAME = "osiris_source" |
|
|
|
def _info(self) -> datasets.DatasetInfo: |
|
|
|
if self.config.schema == "source": |
|
|
|
features = datasets.Features( |
|
{ |
|
"Pmid": datasets.Value("string"), |
|
"Title": datasets.Value("string"), |
|
"Abstract": datasets.Value("string"), |
|
"genes": [ |
|
{ |
|
"g_id": datasets.Value("string"), |
|
"g_lex": datasets.Value("string"), |
|
"offsets": [[datasets.Value("int32")]], |
|
} |
|
], |
|
"variants": [ |
|
{ |
|
"v_id": datasets.Value("string"), |
|
"v_lex": datasets.Value("string"), |
|
"v_norm": datasets.Value("string"), |
|
"offsets": [[datasets.Value("int32")]], |
|
} |
|
], |
|
} |
|
) |
|
|
|
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]: |
|
|
|
urls = _URLS[_DATASETNAME] |
|
data_dir = dl_manager.download(urls) |
|
|
|
return [ |
|
datasets.SplitGenerator( |
|
name=datasets.Split.TRAIN, |
|
|
|
gen_kwargs={ |
|
"filepath": os.path.join(data_dir[0]), |
|
"split": "data", |
|
}, |
|
) |
|
] |
|
|
|
def _get_offsets(self, parent: ET.Element, child: ET.Element) -> List[int32]: |
|
""" |
|
Retrieves character offsets for child from parent. |
|
""" |
|
parent_text = " ".join( |
|
[ |
|
" ".join([t for t in c.itertext()]) |
|
for c in list(parent) |
|
if c.tag != "Pmid" |
|
] |
|
) |
|
child_text = " ".join([t for t in child.itertext()]) |
|
start = parent_text.index(child_text) |
|
end = start + len(child_text) |
|
return [start, end] |
|
|
|
def _get_dict(self, elem: ET.Element) -> dict: |
|
""" |
|
Retrieves dict from XML element. |
|
""" |
|
elem_d = dict() |
|
for child in elem: |
|
elem_d[child.tag] = {} |
|
elem_d[child.tag]["text"] = " ".join([t for t in child.itertext()]) |
|
|
|
if child.tag != "Pmid": |
|
elem_d[child.tag]["offsets"] = self._get_offsets(elem, child) |
|
|
|
for c in child: |
|
elem_d[c.tag] = [] |
|
|
|
for c in child: |
|
c_dict = c.attrib |
|
c_dict["offsets"] = self._get_offsets(elem, c) |
|
elem_d[c.tag].append(c.attrib) |
|
|
|
return elem_d |
|
|
|
def _handle_missing_variants(self, row: dict) -> dict: |
|
""" |
|
If variant is not present in the row this function adds one variant |
|
with no data (to make looping though items possible) and returns the new row. |
|
These mocked variants will be romoved after parsing. |
|
Otherwise returns unchanged row. |
|
""" |
|
|
|
if row.get("variant", 0) == 0: |
|
row["variant"] = [ |
|
{"v_id": "", "v_lex": "", "v_norm": "", "offsets": [0, 0]} |
|
] |
|
return row |
|
|
|
def _get_entities(self, row: dict) -> List[dict]: |
|
""" |
|
Retrieves two lists of dicts for genes and variants. |
|
After that, chains both together. |
|
""" |
|
genes = [ |
|
{ |
|
"id": str(uuid.uuid4()), |
|
"offsets": [gene["offsets"]], |
|
"text": [gene["g_lex"]], |
|
"type": "gene", |
|
"normalized": [{"db_name": "NCBI Gene", "db_id": gene["g_id"]}], |
|
} |
|
for gene in row["gene"] |
|
] |
|
|
|
variants = [ |
|
{ |
|
"id": str(uuid.uuid4()), |
|
"offsets": [variant["offsets"]], |
|
"text": [variant["v_lex"]], |
|
"type": "variant", |
|
"normalized": [ |
|
{ |
|
"db_name": "HGVS-like" if variant["v_id"] == "No" else "dbSNP", |
|
"db_id": variant["v_norm"] |
|
if variant["v_id"] == "No" |
|
else variant["v_id"], |
|
} |
|
], |
|
} |
|
for variant in row["variant"] |
|
if variant["v_id"] != "" |
|
] |
|
return list(itertools.chain(genes, variants)) |
|
|
|
def _generate_examples(self, filepath, split): |
|
|
|
root = ET.parse(filepath).getroot() |
|
uid = 0 |
|
if self.config.schema == "source": |
|
for elem in list(root): |
|
row = self._get_dict(elem) |
|
|
|
|
|
row = self._handle_missing_variants(row) |
|
uid += 1 |
|
yield uid, { |
|
"Pmid": row["Pmid"]["text"], |
|
"Title": { |
|
"offsets": [row["Title"]["offsets"]], |
|
"text": row["Title"]["text"], |
|
}, |
|
"Abstract": { |
|
"offsets": [row["Abstract"]["offsets"]], |
|
"text": row["Abstract"]["text"], |
|
}, |
|
"genes": [ |
|
{ |
|
"g_id": gene["g_id"], |
|
"g_lex": gene["g_lex"], |
|
"offsets": [gene["offsets"]], |
|
} |
|
for gene in row["gene"] |
|
], |
|
"variants": [ |
|
{ |
|
"v_id": variant["v_id"], |
|
"v_lex": variant["v_lex"], |
|
"v_norm": variant["v_norm"], |
|
"offsets": [variant["offsets"]], |
|
} |
|
for variant in row["variant"] |
|
], |
|
} |
|
|
|
elif self.config.schema == "bigbio_kb": |
|
|
|
for elem in list(root): |
|
row = self._get_dict(elem) |
|
|
|
|
|
row = self._handle_missing_variants(row) |
|
uid += 1 |
|
yield uid, { |
|
"id": str(uid), |
|
"document_id": row["Pmid"]["text"], |
|
"passages": [ |
|
{ |
|
"id": str(uuid.uuid4()), |
|
"type": "title", |
|
"text": [row["Title"]["text"]], |
|
"offsets": [row["Title"]["offsets"]], |
|
}, |
|
{ |
|
"id": str(uuid.uuid4()), |
|
"type": "abstract", |
|
"text": [row["Abstract"]["text"]], |
|
"offsets": [row["Abstract"]["offsets"]], |
|
}, |
|
], |
|
"entities": self._get_entities(row), |
|
"relations": [], |
|
"events": [], |
|
"coreferences": [], |
|
} |
|
|