Upload 2 files

E3C.py

@@ -0,0 +1,229 @@
+# pip install bs4 syntok
+
+import os
+import random
+
+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 E3C(datasets.GeneratorBasedBuilder):
+
+    BUILDER_CONFIGS = [
+        datasets.BuilderConfig(name=f"{lang}", version="1.0.0", description=f"The {lang} subset of the E3C corpus") for lang in _LANGUAGES
+    ]
+
+    def _info(self):
+
+        features = datasets.Features(
+            {
+                "id": datasets.Value("string"),
+                "text": datasets.Value("string"),
+                "tokens": datasets.Sequence(datasets.Value("string")),
+                "ner_clinical_tags": datasets.Sequence(
+                    datasets.features.ClassLabel(
+                        names=["O","B-CLINENTITY","I-CLINENTITY"],
+                    ),
+                ),
+                "ner_temporal_tags": datasets.Sequence(
+                    datasets.features.ClassLabel(
+                        names=["O", "B-EVENT", "B-ACTOR", "B-BODYPART", "B-TIMEX3", "B-RML", "I-EVENT", "I-ACTOR", "I-BODYPART", "I-TIMEX3", "I-RML"],
+                    ),
+                ),
+            }
+        )
+
+        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)
+
+        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, "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, "layer1"),
+                    "split": "validation",
+                },
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.TEST,
+                gen_kwargs={
+                    "filepath": os.path.join(data_dir, "E3C-Corpus-2.0.0/data_validation", self.config.name, "layer2"),
+                    "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
+
+        for content in self.get_parsed_data(filepath):
+
+            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}"
+
+                all_res.append({
+                    "id": key,
+                    "text": sentence[-1],
+                    "tokens": list(map(lambda token: token[2], filtered_tokens)),
+                    "ner_clinical_tags": clinical_labels,
+                    "ner_temporal_tags": temporal_information_labels,
+                })
+
+                key += 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

test_e3c.py

@@ -0,0 +1,8 @@
+import json
+
+from datasets import load_dataset
+
+dataset = load_dataset("./E3C.py", name="French")
+print(dataset)
+# print(dataset["train"][0])
+print(json.dumps(dataset["train"][0], sort_keys=True, indent=4))