|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
""" |
|
Named entity recognition (NER) is an important first step for text mining the biomedical literature. |
|
Evaluating the performance of biomedical NER systems is impossible without a standardized test corpus. |
|
The annotation of such a corpus for gene/protein name NER is a difficult process due to the complexity |
|
of gene/protein names. We describe the construction and annotation of GENETAG, a corpus of 20K MEDLINE® |
|
sentences for gene/protein NER. 15K GENETAG sentences were used for the BioCreAtIvE Task 1A Competition. |
|
""" |
|
|
|
|
|
import re |
|
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{Tanabe2005, |
|
author = {Lorraine Tanabe and Natalie Xie and Lynne H Thom and Wayne Matten and W John Wilbur}, |
|
title = {{GENETAG}: a tagged corpus for gene/protein named entity recognition}, |
|
journal = {{BMC} Bioinformatics}, |
|
volume = {6}, |
|
year = {2005}, |
|
url = {https://doi.org/10.1186/1471-2105-6-S1-S3}, |
|
doi = {10.1186/1471-2105-6-s1-s3}, |
|
biburl = {}, |
|
bibsource = {} |
|
} |
|
""" |
|
|
|
_DATASETNAME = "genetag" |
|
_DISPLAYNAME = "GENETAG" |
|
|
|
_DESCRIPTION = """\ |
|
Named entity recognition (NER) is an important first step for text mining the biomedical literature. |
|
Evaluating the performance of biomedical NER systems is impossible without a standardized test corpus. |
|
The annotation of such a corpus for gene/protein name NER is a difficult process due to the complexity |
|
of gene/protein names. We describe the construction and annotation of GENETAG, a corpus of 20K MEDLINE® |
|
sentences for gene/protein NER. 15K GENETAG sentences were used for the BioCreAtIvE Task 1A Competition.. |
|
""" |
|
|
|
_HOMEPAGE = "https://github.com/openbiocorpora/genetag" |
|
|
|
_LICENSE = 'National Center fr Biotechnology Information PUBLIC DOMAIN NOTICE' |
|
|
|
_BASE_URL = ( |
|
"https://raw.githubusercontent.com/openbiocorpora/genetag/master/original-data/" |
|
) |
|
|
|
_URLS = { |
|
"test": { |
|
"correct": f"{_BASE_URL}test/Correct.Data", |
|
"gold": f"{_BASE_URL}test/Gold.format", |
|
"text": f"{_BASE_URL}test/TOKENIZED_CORPUS", |
|
"postagspath": f"{_BASE_URL}test/TAGGED_GENE_CORPUS", |
|
}, |
|
"train": { |
|
"correct": f"{_BASE_URL}train/Correct.Data", |
|
"gold": f"{_BASE_URL}train/Gold.format", |
|
"text": f"{_BASE_URL}train/TOKENIZED_CORPUS", |
|
"postagspath": f"{_BASE_URL}train/TAGGED_GENE_CORPUS", |
|
}, |
|
"round1": { |
|
"correct": f"{_BASE_URL}round1/Correct.Data", |
|
"gold": f"{_BASE_URL}round1/Gold.format", |
|
"text": f"{_BASE_URL}round1/TOKENIZED_CORPUS", |
|
"postagspath": f"{_BASE_URL}round1/TAGGED_GENE_CORPUS", |
|
}, |
|
} |
|
|
|
_SUPPORTED_TASKS = [Tasks.NAMED_ENTITY_RECOGNITION] |
|
|
|
_SOURCE_VERSION = "1.0.0" |
|
|
|
_BIGBIO_VERSION = "1.0.0" |
|
|
|
|
|
class GenetagDataset(datasets.GeneratorBasedBuilder): |
|
"""GENETAG is a corpus of 15K MEDLINE sentences with annotations for gene/protein NER""" |
|
|
|
SOURCE_VERSION = datasets.Version(_SOURCE_VERSION) |
|
BIGBIO_VERSION = datasets.Version(_BIGBIO_VERSION) |
|
|
|
BUILDER_CONFIGS = [] |
|
for annot_type in ["gold", "correct"]: |
|
BUILDER_CONFIGS.append( |
|
BigBioConfig( |
|
name=f"genetag{annot_type}_source", |
|
version=SOURCE_VERSION, |
|
description=f"GENETAG {annot_type} annotation source schema", |
|
schema="source", |
|
subset_id=f"genetag{annot_type}", |
|
) |
|
) |
|
|
|
BUILDER_CONFIGS.append( |
|
BigBioConfig( |
|
name=f"genetag{annot_type}_bigbio_kb", |
|
version=BIGBIO_VERSION, |
|
description=f"GENETAG {annot_type} annotation bigbio schema", |
|
schema="bigbio_kb", |
|
subset_id=f"genetag{annot_type}", |
|
) |
|
) |
|
|
|
DEFAULT_CONFIG_NAME = "genetaggold_source" |
|
|
|
def _info(self) -> datasets.DatasetInfo: |
|
|
|
if self.config.schema == "source": |
|
features = datasets.Features( |
|
{ |
|
"doc_id": datasets.Value("string"), |
|
"text": datasets.Value("string"), |
|
"tokenized_text": datasets.Sequence(datasets.Value("string")), |
|
"pos_tags": datasets.Sequence(datasets.Value("string")), |
|
"entities": [ |
|
{ |
|
"token_offsets": datasets.Sequence( |
|
[datasets.Value("int32")] |
|
), |
|
"text": datasets.Value("string"), |
|
"type": datasets.Value("string"), |
|
"entity_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 |
|
data_dir = dl_manager.download(urls) |
|
annotation_type = self.config.subset_id.split("genetag")[ |
|
-1 |
|
] |
|
|
|
return [ |
|
datasets.SplitGenerator( |
|
name=datasets.Split.TRAIN, |
|
|
|
gen_kwargs={ |
|
"filepath": data_dir["train"]["text"], |
|
"annotationpath": data_dir["train"][annotation_type], |
|
"postagspath": data_dir["train"]["postagspath"], |
|
"split": "train", |
|
}, |
|
), |
|
datasets.SplitGenerator( |
|
name=datasets.Split.TEST, |
|
gen_kwargs={ |
|
"filepath": data_dir["test"]["text"], |
|
"annotationpath": data_dir["test"][annotation_type], |
|
"postagspath": data_dir["test"]["postagspath"], |
|
"split": "test", |
|
}, |
|
), |
|
datasets.SplitGenerator( |
|
name=datasets.Split.VALIDATION, |
|
gen_kwargs={ |
|
"filepath": data_dir["round1"]["text"], |
|
"annotationpath": data_dir["round1"][annotation_type], |
|
"postagspath": data_dir["round1"]["postagspath"], |
|
"split": "dev", |
|
}, |
|
), |
|
] |
|
|
|
def _generate_examples( |
|
self, filepath, annotationpath, postagspath, split: str |
|
) -> Tuple[int, Dict]: |
|
"""Yields examples as (key, example) tuples.""" |
|
corpus, annotations = self._read_files(filepath, annotationpath, postagspath) |
|
|
|
if self.config.schema == "source": |
|
source_examples = self._parse_annotations_source(corpus, annotations, split) |
|
for uid, doc_id in enumerate(source_examples): |
|
yield uid, source_examples[doc_id] |
|
|
|
elif self.config.schema == "bigbio_kb": |
|
bb_kb_examples = self._parse_annotations_bb(corpus, annotations, split) |
|
for uid, doc_id in enumerate(bb_kb_examples): |
|
yield uid, bb_kb_examples[doc_id] |
|
|
|
def _read_files(self, filepath, annotation_path, postagspath): |
|
""" |
|
Reads text corpus and annotations |
|
""" |
|
corpus, annotations = dict(), dict() |
|
|
|
|
|
with open(filepath, "r") as texts: |
|
for line in texts: |
|
|
|
sentence_id = re.search(r"@@\d+", line).group(0) |
|
|
|
text = re.sub(r"(/TAG|\/\.)", "", line).split(sentence_id)[-1].strip() |
|
corpus[sentence_id] = { |
|
"text": text, |
|
"tokenized_text": text.split(), |
|
} |
|
|
|
with open(postagspath, "r") as texts: |
|
for line in texts: |
|
sentence_id = re.search(r"@@\d+", line).group(0) |
|
_tags = re.findall(r"(\/[A-Z]+|\/[.,:()\"]+)", line) |
|
pos_tags = [i.replace("/", "") for i in _tags] |
|
corpus[sentence_id]["pos_tags"] = pos_tags |
|
|
|
|
|
with open(annotation_path, "r") as annots: |
|
for line in annots: |
|
row = line.split("|") |
|
if len(row) == 3: |
|
sentence_id = row[0].strip() |
|
annot = row[2].strip() |
|
start = int(row[1].split()[0]) |
|
end = int(row[1].split()[1]) |
|
if sentence_id in annotations: |
|
annotations[sentence_id].append( |
|
{"text": annot, "token_start": start, "token_end": end} |
|
) |
|
else: |
|
annotations[sentence_id] = [ |
|
{"text": annot, "token_start": start, "token_end": end} |
|
] |
|
|
|
return corpus, annotations |
|
|
|
def _parse_annotations_source(self, corpus, annotations, split) -> Dict: |
|
""" |
|
Reads source annotations |
|
""" |
|
|
|
source_examples = {} |
|
for sent_id in corpus: |
|
|
|
text = corpus[sent_id]["text"] |
|
source_examples[sent_id] = { |
|
"doc_id": sent_id, |
|
"text": text, |
|
"tokenized_text": corpus[sent_id]["tokenized_text"], |
|
"pos_tags": corpus[sent_id]["pos_tags"], |
|
"entities": [], |
|
} |
|
|
|
if annotations.get(sent_id): |
|
for uid, entity in enumerate(annotations[sent_id]): |
|
source_examples[sent_id]["entities"].append( |
|
{ |
|
"text": entity["text"], |
|
"type": "NEWGENE", |
|
"token_offsets": [ |
|
[entity["token_start"], entity["token_end"]] |
|
], |
|
"entity_id": f"{sent_id}_{uid+1}", |
|
} |
|
) |
|
|
|
return source_examples |
|
|
|
def _parse_annotations_bb(self, corpus, annotations, split) -> Dict: |
|
""" |
|
Convert source annotations to bigbio schema annotations |
|
""" |
|
bb_examples = {} |
|
|
|
for sent_id in corpus: |
|
text = corpus[sent_id]["text"] |
|
bb_examples[sent_id] = { |
|
"id": sent_id, |
|
"document_id": sent_id, |
|
"passages": [ |
|
{ |
|
"id": f"{sent_id}_text", |
|
"type": "sentence", |
|
"text": [text], |
|
"offsets": [[0, len(text)]], |
|
} |
|
], |
|
"entities": self._add_entities_bb(sent_id, annotations[sent_id], text) |
|
if annotations.get(sent_id) |
|
else [], |
|
"events": [], |
|
"coreferences": [], |
|
"relations": [], |
|
} |
|
|
|
return bb_examples |
|
|
|
def _add_entities_bb(self, doc_id, annotations, text) -> List: |
|
""" |
|
Returns entities in bigbio schema when given annotations |
|
(with token indices) for some text |
|
a text. e.g: - |
|
|
|
doc_id: @@21234669976 |
|
annotations: [{'text': 'HLH', 'token_start': 9, 'token_end': 9}, |
|
{'text': 'AP-4 HLH', 'token_start': 8, 'token_end': 9}, |
|
{'text': 'AP-4 HLH motif', 'token_start': 8, 'token_end': 10}] |
|
text: 'Like other members of this family , the AP-4 HLH motif and the adjacent |
|
basic domain are necessary and sufficient to confer site-specific DNA binding .' |
|
|
|
returns: [ |
|
{'offsets': [[45, 48]], |
|
'text': ['HLH'], |
|
'type': 'NEWGENE', |
|
'normalized': [], |
|
'id': '@@21234669976_1'}, |
|
{'offsets': [[40, 48]], |
|
'text': ['AP-4 HLH'], |
|
'type': 'NEWGENE', |
|
'normalized': [], |
|
'id': '@@21234669976_2'}, |
|
{'offsets': [[40, 54]], |
|
'text': ['AP-4 HLH motif'], |
|
'type': 'NEWGENE', |
|
'normalized': [], |
|
'id': '@@21234669976_3'} |
|
] |
|
|
|
Uses the given token level indices to pick correct entities |
|
and assign character offsets |
|
""" |
|
|
|
entities = [] |
|
for uid, entity in enumerate(annotations): |
|
start = entity["token_start"] |
|
end = entity["token_end"] |
|
for i in range(len(text)): |
|
|
|
if text[i:].startswith(entity["text"]): |
|
|
|
token_end = end + 1 |
|
token_end_char = i + len(entity["text"]) |
|
if ( |
|
" ".join(text.split()[start:token_end]) |
|
== text[i:token_end_char] |
|
): |
|
annot = { |
|
"offsets": [[i, i + len(entity["text"])]], |
|
"text": [entity["text"]], |
|
"type": "NEWGENE", |
|
"normalized": [], |
|
} |
|
if annot not in entities: |
|
annot["id"] = f"{doc_id}_{uid+1}" |
|
entities.append(annot) |
|
break |
|
return entities |
|
|