|
import os |
|
|
|
import datasets |
|
from bs4 import ResultSet, BeautifulSoup |
|
from datasets import DownloadManager |
|
|
|
_CITATION = """\ |
|
@report{Magnini2021, |
|
author = {Bernardo Magnini and Begoña Altuna and Alberto Lavelli and Manuela Speranza |
|
and Roberto Zanoli and Fondazione Bruno Kessler}, |
|
keywords = {Clinical data,clinical enti-ties,corpus,multilingual,temporal information}, |
|
title = {The E3C Project: |
|
European Clinical Case Corpus El proyecto E3C: European Clinical Case Corpus}, |
|
url = {https://uts.nlm.nih.gov/uts/umls/home}, |
|
year = {2021}, |
|
} |
|
|
|
""" |
|
|
|
_DESCRIPTION = """\ |
|
The European Clinical Case Corpus (E3C) project aims at collecting and \ |
|
annotating a large corpus of clinical documents in five European languages (Spanish, \ |
|
Basque, English, French and Italian), which will be freely distributed. Annotations \ |
|
include temporal information, to allow temporal reasoning on chronologies, and \ |
|
information about clinical entities based on medical taxonomies, to be used for semantic reasoning. |
|
""" |
|
|
|
_URL = "https://github.com/hltfbk/E3C-Corpus/archive/refs/tags/v2.0.0.zip" |
|
|
|
|
|
class E3CConfig(datasets.BuilderConfig): |
|
"""BuilderConfig for SQUAD.""" |
|
|
|
def __init__(self, **kwargs): |
|
"""BuilderConfig for SQUAD. |
|
Args: |
|
**kwargs: keyword arguments forwarded to super. |
|
""" |
|
self.layer = kwargs.pop("layer") |
|
super(E3CConfig, self).__init__(**kwargs) |
|
|
|
|
|
class E3C(datasets.GeneratorBasedBuilder): |
|
VERSION = datasets.Version("1.1.0") |
|
BUILDER_CONFIGS = [ |
|
E3CConfig( |
|
name="en", |
|
version=VERSION, |
|
description="this is the split of the layer 1 for English of E3C dataset", |
|
layer="1", |
|
), |
|
E3CConfig( |
|
name="es", |
|
version=VERSION, |
|
description="this is the split of the layer 1 for Spanish of E3C dataset", |
|
layer="1", |
|
), |
|
E3CConfig( |
|
name="eu", |
|
version=VERSION, |
|
description="this is the split of the layer 1 for Basque of E3C dataset", |
|
layer="1", |
|
), |
|
E3CConfig( |
|
name="fr", |
|
version=VERSION, |
|
description="this is the split of the layer 1 for French of E3C dataset", |
|
layer="1", |
|
), |
|
E3CConfig( |
|
name="it", |
|
version=VERSION, |
|
description="this is the split of the layer 1 for Italian of E3C dataset", |
|
layer="1", |
|
), |
|
] |
|
|
|
def _info(self): |
|
"""This method specifies the DatasetInfo which contains information and typings.""" |
|
features = datasets.Features( |
|
{ |
|
"tokens": datasets.Sequence(datasets.Value("string")), |
|
"ner_tags": datasets.Sequence( |
|
datasets.features.ClassLabel( |
|
names=[ |
|
"O", |
|
"CLINENTITY", |
|
"EVENT", |
|
"ACTOR", |
|
"BODYPART", |
|
"TIMEX3", |
|
"RML", |
|
], |
|
), |
|
), |
|
} |
|
) |
|
return datasets.DatasetInfo( |
|
description=_DESCRIPTION, |
|
features=features, |
|
citation=_CITATION, |
|
supervised_keys=None, |
|
) |
|
|
|
def _split_generators(self, dl_manager: DownloadManager) -> list[datasets.SplitGenerator]: |
|
"""Returns SplitGenerators who contains all the difference splits of the dataset. |
|
Each language has its own split and each split has 3 different layers (sub-split): |
|
- layer 1: full manual annotation of clinical entities, temporal information and |
|
factuality, for benchmarking and linguistic analysis. |
|
- layer 2: semi-automatic annotation of clinical entities |
|
- layer 3: non-annotated documents |
|
Args: |
|
dl_manager: A `datasets.utils.DownloadManager` that can be used to download and |
|
extract URLs. |
|
Returns: |
|
A list of `datasets.SplitGenerator`. Contains all subsets of the dataset depending on |
|
the language and the layer. |
|
""" |
|
url = _URL |
|
data_dir = dl_manager.download_and_extract(url) |
|
language = { |
|
"en": "English", |
|
"es": "Spanish", |
|
"eu": "Basque", |
|
"fr": "French", |
|
"it": "Italian", |
|
}[self.config.name] |
|
return [ |
|
datasets.SplitGenerator( |
|
name=self.config.name, |
|
gen_kwargs={ |
|
"filepath": os.path.join( |
|
data_dir, |
|
"E3C-Corpus-2.0.0/data_annotation", |
|
language, |
|
f"layer{self.config.layer}", |
|
), |
|
}, |
|
), |
|
] |
|
|
|
@staticmethod |
|
def get_annotations(entities: ResultSet, text: str) -> list: |
|
"""Extract the offset, the text and the type of the entity. |
|
|
|
Args: |
|
entities: The entities to extract. |
|
text: The text of the document. |
|
Returns: |
|
A list of list containing the offset, the text and the type of the entity. |
|
""" |
|
return [ |
|
[ |
|
int(entity.get("begin")), |
|
int(entity.get("end")), |
|
text[int(entity.get("begin")) : int(entity.get("end"))], |
|
] |
|
for entity in entities |
|
] |
|
|
|
def get_parsed_data(self, filepath: str): |
|
"""Parse the data from the E3C dataset and store it in a dictionary. |
|
Iterate over the files in the dataset and parse for each file the following entities: |
|
- CLINENTITY |
|
- EVENT |
|
- ACTOR |
|
- BODYPART |
|
- TIMEX3 |
|
- RML |
|
for each entity, we extract the offset, the text and the type of the entity. |
|
|
|
Args: |
|
filepath: The path to the folder containing the files to parse. |
|
""" |
|
for root, _, files in os.walk(filepath): |
|
for file in files: |
|
with open(f"{root}/{file}") as soup_file: |
|
soup = BeautifulSoup(soup_file, "xml") |
|
text = soup.find("cas:Sofa").get("sofaString") |
|
yield { |
|
"CLINENTITY": self.get_annotations( |
|
soup.find_all("custom:CLINENTITY"), text |
|
), |
|
"EVENT": self.get_annotations(soup.find_all("custom:EVENT"), text), |
|
"ACTOR": self.get_annotations(soup.find_all("custom:ACTOR"), text), |
|
"BODYPART": self.get_annotations(soup.find_all("custom:BODYPART"), text), |
|
"TIMEX3": self.get_annotations(soup.find_all("custom:TIMEX3"), text), |
|
"RML": self.get_annotations(soup.find_all("custom:RML"), text), |
|
"SENTENCE": self.get_annotations(soup.find_all("type4:Sentence"), text), |
|
"TOKENS": self.get_annotations(soup.find_all("type4:Token"), text), |
|
} |
|
|
|
def _generate_examples(self, filepath) -> tuple[str, dict]: |
|
"""Yields examples as (key, example) tuples. |
|
Args: |
|
filepath: The path to the folder containing the files to parse. |
|
Yields: |
|
The unique id of an example and the example itself containing tokens and ner_tags in |
|
IOB format. |
|
""" |
|
guid = 0 |
|
for content in self.get_parsed_data(filepath): |
|
for sentence in content["SENTENCE"]: |
|
filtered_tokens = list( |
|
filter( |
|
lambda token: token[0] >= sentence[0] and token[1] <= sentence[1], |
|
content["TOKENS"], |
|
) |
|
) |
|
labels = ["O"] * len(filtered_tokens) |
|
for entity_type in [ |
|
"CLINENTITY", |
|
"EVENT", |
|
"ACTOR", |
|
"BODYPART", |
|
"TIMEX3", |
|
"RML", |
|
]: |
|
if len(content[entity_type]) != 0 and sentence[1] >= content[entity_type][0][0]: |
|
for entities in list( |
|
filter( |
|
lambda entity: sentence[0] <= entity[0] <= sentence[1], |
|
content[entity_type], |
|
) |
|
): |
|
annotated_tokens = [ |
|
idx_token |
|
for idx_token, token in enumerate(filtered_tokens) |
|
if token[0] >= entities[0] and token[1] <= entities[1] |
|
] |
|
for idx_token in annotated_tokens: |
|
if idx_token == annotated_tokens[0]: |
|
labels[idx_token] = f"{entity_type}" |
|
else: |
|
labels[idx_token] = f"{entity_type}" |
|
guid += 1 |
|
yield guid, { |
|
"tokens": list(map(lambda tokens: tokens[2], filtered_tokens)), |
|
"ner_tags": labels, |
|
} |
|
|
