| |
|
|
| import os |
| import random |
| import requests |
|
|
| import datasets |
|
|
| import numpy as np |
| from bs4 import BeautifulSoup, ResultSet |
| from syntok.tokenizer import Tokenizer |
|
|
| tokenizer = Tokenizer() |
|
|
| _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 = """\ |
| E3C is a freely available multilingual corpus (English, French, Italian, Spanish, and Basque) \ |
| of semantically annotated clinical narratives to allow for the linguistic analysis, benchmarking, \ |
| and training of information extraction systems. It consists of two types of annotations: \ |
| (i) clinical entities (e.g., pathologies), (ii) temporal information and factuality (e.g., events). \ |
| Researchers can use the benchmark training and test splits of our corpus to develop and test \ |
| their own models. |
| """ |
|
|
| _URL = "https://github.com/hltfbk/E3C-Corpus/archive/refs/tags/v2.0.0.zip" |
|
|
| _LANGUAGES = ["English","Spanish","Basque","French","Italian"] |
|
|
| class StringIndex: |
|
|
| def __init__(self, vocab): |
|
|
| self.vocab_struct = {} |
|
|
| print("Start building the index!") |
| for t in vocab: |
|
|
| if len(t) == 0: |
| continue |
|
|
| |
| key = (t[0], len(t)) |
|
|
| if (key in self.vocab_struct) == False: |
| self.vocab_struct[key] = [] |
| |
| self.vocab_struct[key].append(t) |
|
|
| print("Finished building the index!") |
|
|
| def find(self, t): |
| |
| key = (t[0], len(t)) |
| |
| if (key in self.vocab_struct) == False: |
| return "is_oov" |
| |
| return "is_not_oov" if t in self.vocab_struct[key] else "is_oov" |
|
|
| _VOCAB = StringIndex(vocab=requests.get("https://huggingface.co/datasets/BioMedTok/vocabulary_nachos_lowercased/resolve/main/vocabulary_nachos_lowercased.txt").text.split("\n")) |
|
|
| class E3C(datasets.GeneratorBasedBuilder): |
|
|
| BUILDER_CONFIGS = [ |
| datasets.BuilderConfig(name=f"{lang}_clinical", version="1.0.0", description=f"The {lang} subset of the E3C corpus") for lang in _LANGUAGES |
| ] |
|
|
| BUILDER_CONFIGS += [ |
| datasets.BuilderConfig(name=f"{lang}_temporal", version="1.0.0", description=f"The {lang} subset of the E3C corpus") for lang in _LANGUAGES |
| ] |
| |
| DEFAULT_CONFIG_NAME = "French_clinical" |
|
|
| def _info(self): |
| |
| if self.config.name == "default": |
| self.config.name = self.DEFAULT_CONFIG_NAME |
|
|
| if self.config.name.find("clinical") != -1: |
| names = ["O","B-CLINENTITY","I-CLINENTITY"] |
| elif self.config.name.find("temporal") != -1: |
| names = ["O", "B-EVENT", "B-ACTOR", "B-BODYPART", "B-TIMEX3", "B-RML", "I-EVENT", "I-ACTOR", "I-BODYPART", "I-TIMEX3", "I-RML"] |
| |
| features = datasets.Features( |
| { |
| "id": datasets.Value("string"), |
| "text": datasets.Value("string"), |
| "tokens": datasets.Sequence(datasets.Value("string")), |
| "ner_tags": datasets.Sequence( |
| datasets.features.ClassLabel( |
| names=names, |
| ), |
| ), |
| "is_oov": datasets.Sequence( |
| datasets.features.ClassLabel( |
| names=['is_not_oov', 'is_oov'], |
| ), |
| ), |
| } |
| ) |
| |
| return datasets.DatasetInfo( |
| description=_DESCRIPTION, |
| features=features, |
| citation=_CITATION, |
| supervised_keys=None, |
| ) |
|
|
| def _split_generators(self, dl_manager): |
|
|
| data_dir = dl_manager.download_and_extract(_URL) |
|
|
| print(data_dir) |
|
|
| if self.config.name.find("clinical") != -1: |
| |
| print("clinical") |
| |
| return [ |
| datasets.SplitGenerator( |
| name=datasets.Split.TRAIN, |
| gen_kwargs={ |
| "filepath": os.path.join(data_dir, "E3C-Corpus-2.0.0/data_annotation", self.config.name.replace("_clinical",""), "layer2"), |
| "split": "train", |
| }, |
| ), |
| datasets.SplitGenerator( |
| name=datasets.Split.VALIDATION, |
| gen_kwargs={ |
| "filepath": os.path.join(data_dir, "E3C-Corpus-2.0.0/data_annotation", self.config.name.replace("_clinical",""), "layer2"), |
| "split": "validation", |
| }, |
| ), |
| datasets.SplitGenerator( |
| name=datasets.Split.TEST, |
| gen_kwargs={ |
| "filepath": os.path.join(data_dir, "E3C-Corpus-2.0.0/data_annotation", self.config.name.replace("_clinical",""), "layer1"), |
| "split": "test", |
| }, |
| ), |
| ] |
| |
| elif self.config.name.find("temporal") != -1: |
| |
| print("temporal") |
| |
| return [ |
| datasets.SplitGenerator( |
| name=datasets.Split.TRAIN, |
| gen_kwargs={ |
| "filepath": os.path.join(data_dir, "E3C-Corpus-2.0.0/data_annotation", self.config.name.replace("_temporal",""), "layer1"), |
| "split": "train", |
| }, |
| ), |
| datasets.SplitGenerator( |
| name=datasets.Split.VALIDATION, |
| gen_kwargs={ |
| "filepath": os.path.join(data_dir, "E3C-Corpus-2.0.0/data_annotation", self.config.name.replace("_temporal",""), "layer1"), |
| "split": "validation", |
| }, |
| ), |
| datasets.SplitGenerator( |
| name=datasets.Split.TEST, |
| gen_kwargs={ |
| "filepath": os.path.join(data_dir, "E3C-Corpus-2.0.0/data_annotation", self.config.name.replace("_temporal",""), "layer1"), |
| "split": "test", |
| }, |
| ), |
| ] |
|
|
| @staticmethod |
| def get_annotations(entities: ResultSet, text: str) -> list: |
|
|
| return [[ |
| int(entity.get("begin")), |
| int(entity.get("end")), |
| text[int(entity.get("begin")) : int(entity.get("end"))], |
| ] for entity in entities] |
|
|
| def get_clinical_annotations(self, entities: ResultSet, text: str) -> list: |
|
|
| return [[ |
| int(entity.get("begin")), |
| int(entity.get("end")), |
| text[int(entity.get("begin")) : int(entity.get("end"))], |
| entity.get("entityID"), |
| ] for entity in entities] |
|
|
| def get_parsed_data(self, filepath: str): |
|
|
| 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_clinical_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, split): |
|
|
| all_res = [] |
|
|
| key = 0 |
|
|
| parsed_content = self.get_parsed_data(filepath) |
|
|
| for content in parsed_content: |
|
|
| for sentence in content["SENTENCE"]: |
|
|
| tokens = [( |
| token.offset + sentence[0], |
| token.offset + sentence[0] + len(token.value), |
| token.value, |
| ) for token in list(tokenizer.tokenize(sentence[-1]))] |
|
|
| filtered_tokens = list( |
| filter( |
| lambda token: token[0] >= sentence[0] and token[1] <= sentence[1], |
| tokens, |
| ) |
| ) |
|
|
| tokens_offsets = [ |
| [token[0] - sentence[0], token[1] - sentence[0]] for token in filtered_tokens |
| ] |
|
|
| clinical_labels = ["O"] * len(filtered_tokens) |
| clinical_cuid = ["CUI_LESS"] * len(filtered_tokens) |
| temporal_information_labels = ["O"] * len(filtered_tokens) |
|
|
| for entity_type in ["CLINENTITY","EVENT","ACTOR","BODYPART","TIMEX3","RML"]: |
|
|
| if len(content[entity_type]) != 0: |
|
|
| for entities in list(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 entity_type == "CLINENTITY": |
| if idx_token == annotated_tokens[0]: |
| clinical_labels[idx_token] = f"B-{entity_type}" |
| else: |
| clinical_labels[idx_token] = f"I-{entity_type}" |
| clinical_cuid[idx_token] = entities[-1] |
| else: |
| if idx_token == annotated_tokens[0]: |
| temporal_information_labels[idx_token] = f"B-{entity_type}" |
| else: |
| temporal_information_labels[idx_token] = f"I-{entity_type}" |
|
|
| if self.config.name.find("clinical") != -1: |
| _labels = clinical_labels |
| elif self.config.name.find("temporal") != -1: |
| _labels = temporal_information_labels |
| |
| all_res.append({ |
| "id": key, |
| "text": sentence[-1].lower(), |
| "tokens": [tok.lower() for tok in list(map(lambda token: token[2], filtered_tokens))], |
| "ner_tags": _labels, |
| "is_oov": [_VOCAB.find(tt.lower()) for tt in list(map(lambda token: token[2], filtered_tokens))], |
| }) |
| |
| key += 1 |
| |
| if self.config.name.find("clinical") != -1: |
| |
| if split != "test": |
| |
| ids = [r["id"] for r in all_res] |
| |
| random.seed(4) |
| random.shuffle(ids) |
| random.shuffle(ids) |
| random.shuffle(ids) |
| |
| train, validation = np.split(ids, [int(len(ids)*0.8738)]) |
| |
| if split == "train": |
| allowed_ids = list(train) |
| elif split == "validation": |
| allowed_ids = list(validation) |
| |
| for r in all_res: |
| if r["id"] in allowed_ids: |
| yield r["id"], r |
| else: |
| |
| for r in all_res: |
| yield r["id"], r |
| |
| elif self.config.name.find("temporal") != -1: |
| |
| ids = [r["id"] for r in all_res] |
| |
| random.seed(4) |
| random.shuffle(ids) |
| random.shuffle(ids) |
| random.shuffle(ids) |
| |
| train, validation, test = np.split(ids, [int(len(ids)*0.70), int(len(ids)*0.80)]) |
| |
| if split == "train": |
| allowed_ids = list(train) |
| elif split == "validation": |
| allowed_ids = list(validation) |
| elif split == "test": |
| allowed_ids = list(test) |
| |
| for r in all_res: |
| if r["id"] in allowed_ids: |
| yield r["id"], r |
