Update PxCorpus.py

PxCorpus.py

@@ -1,170 +1,179 @@
-# coding=utf-8
-# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""DIAMED"""
+# pip install bs4 syntok
 
 import os
-import json
-import math
+import random
 
 import datasets
 
-_DESCRIPTION = """\
-DIAMED
-"""
+import numpy as np
+from bs4 import BeautifulSoup, ResultSet
+from syntok.tokenizer import Tokenizer
 
-_HOMEPAGE = ""
+tokenizer = Tokenizer()
 
-_LICENSE = "Apache License 2.0"
+_CITATION = """\
+@InProceedings{Kocabiyikoglu2022,
+  author =     "Alican Kocabiyikoglu and Fran{\c c}ois Portet and Prudence Gibert and Hervé Blanchon and Jean-Marc Babouchkine and Gaëtan Gavazzi",
+  title =     "A Spoken Drug Prescription Dataset in French for Spoken Language Understanding",
+  booktitle =     "13th Language Resources and Evaluation Conference (LREC 2022)",
+  year =     "2022",
+  location =     "Marseille, France"
+}
+"""
 
-_URL = "https://huggingface.co/datasets/Dr-BERT/DiaMED/resolve/main/data.zip"
+_DESCRIPTION = """\
+PxSLU is to the best of our knowledge, the first spoken medical drug prescriptions corpus to be distributed. It contains 4 hours of transcribed
+and annotated dialogues of drug prescriptions in French acquired through an experiment with 55 participants experts and non-experts in drug prescriptions.
 
-_CITATION = """\
+The automatic transcriptions were verified by human effort and aligned with semantic labels to allow training of NLP models. The data acquisition
+protocol was reviewed by medical experts and permit free distribution without breach of privacy and regulation.
+
+Overview of the Corpus
 
+The experiment has been performed in wild conditions with naive participants and medical experts. In total, the dataset includes 1981 recordings
+of 55 participants (38% non-experts, 25% doctors, 36% medical practitioners), manually transcribed and semantically annotated.
 """
 
-class DiaMed(datasets.GeneratorBasedBuilder):
-    """DIAMED"""
+_URL = "https://zenodo.org/record/6524162/files/pxslu.zip?download=1"
 
-    VERSION = datasets.Version("1.0.0")
+class PxCorpus(datasets.GeneratorBasedBuilder):
 
     BUILDER_CONFIGS = [
-        datasets.BuilderConfig(name=f"default", version="1.0.0", description=f"DiaMED data"),
+        datasets.BuilderConfig(name=f"default", version="1.0.0", description=f"PxCorpus data"),
     ]
     
     DEFAULT_CONFIG_NAME = "default"
 
     def _info(self):
-
+        
         features = datasets.Features(
             {
-                "identifier": datasets.Value("string"),
-                "title": datasets.Value("string"),
-                "clinical_case": datasets.Value("string"),
-                "topic": datasets.Value("string"),
-                "keywords": datasets.Sequence(
-                    datasets.Value("string"),
+                "id": datasets.Value("string"),
+                "text": datasets.Value("string"),
+                "label": datasets.features.ClassLabel(
+                    names=["medical_prescription", "negate", "none", "replace"],
                 ),
-                "domains": datasets.Sequence(
-                    datasets.Value("string"),
+                "tokens": datasets.Sequence(datasets.Value("string")),
+                "ner_tags": datasets.Sequence(
+                    datasets.features.ClassLabel(
+                        names=['O', 'B-A', 'B-cma_event', 'B-d_dos_form', 'B-d_dos_form_ext', 'B-d_dos_up', 'B-d_dos_val', 'B-dos_cond', 'B-dos_uf', 'B-dos_val', 'B-drug', 'B-dur_ut', 'B-dur_val', 'B-fasting', 'B-freq_days', 'B-freq_int_v1', 'B-freq_int_v1_ut', 'B-freq_int_v2', 'B-freq_int_v2_ut', 'B-freq_startday', 'B-freq_ut', 'B-freq_val', 'B-inn', 'B-max_unit_uf', 'B-max_unit_ut', 'B-max_unit_val', 'B-min_gap_ut', 'B-min_gap_val', 'B-qsp_ut', 'B-qsp_val', 'B-re_ut', 'B-re_val', 'B-rhythm_hour', 'B-rhythm_perday', 'B-rhythm_rec_ut', 'B-rhythm_rec_val', 'B-rhythm_tdte', 'B-roa', 'I-cma_event', 'I-d_dos_form', 'I-d_dos_form_ext', 'I-d_dos_up', 'I-d_dos_val', 'I-dos_cond', 'I-dos_uf', 'I-dos_val', 'I-drug', 'I-fasting', 'I-freq_startday', 'I-inn', 'I-rhythm_tdte', 'I-roa'],
+                    ),
                 ),
-                "collected_at": datasets.Value("string"),
-                "published_at": datasets.Value("string"),
-                "source_url": datasets.Value("string"),
-                "source_name": datasets.Value("string"),
-                "license": datasets.Value("string"),
-                "figures_urls": datasets.Sequence(
-                    datasets.Value("string"),
-                ),
-                "figures_paths": datasets.Sequence(
-                    datasets.Value("string"),
-                ),
-                "figures": datasets.Sequence(
-                    datasets.Image(),
-                ),
-                "icd-10": datasets.features.ClassLabel(names=[
-                    'A00-B99  Certain infectious and parasitic diseases',
-                    'C00-D49  Neoplasms',
-                    'D50-D89  Diseases of the blood and blood-forming organs and certain disorders involving the immune mechanism',
-                    'E00-E89  Endocrine, nutritional and metabolic diseases',
-                    'F01-F99  Mental, Behavioral and Neurodevelopmental disorders',
-                    'G00-G99  Diseases of the nervous system',
-                    'H00-H59  Diseases of the eye and adnexa',
-                    'H60-H95  Diseases of the ear and mastoid process',
-                    'I00-I99  Diseases of the circulatory system',
-                    'J00-J99  Diseases of the respiratory system',
-                    'K00-K95  Diseases of the digestive system',
-                    'L00-L99  Diseases of the skin and subcutaneous tissue',
-                    'M00-M99  Diseases of the musculoskeletal system and connective tissue',
-                    'N00-N99  Diseases of the genitourinary system',
-                    'O00-O9A  Pregnancy, childbirth and the puerperium',
-                    'P00-P96  Certain conditions originating in the perinatal period',
-                    'Q00-Q99  Congenital malformations, deformations and chromosomal abnormalities',
-                    'R00-R99  Symptoms, signs and abnormal clinical and laboratory findings, not elsewhere classified',
-                    'S00-T88  Injury, poisoning and certain other consequences of external causes',
-                    'U00-U85  Codes for special purposes',
-                    'V00-Y99  External causes of morbidity',
-                    'Z00-Z99  Factors influencing health status and contact with health services',
-                ]),
             }
         )
         
         return datasets.DatasetInfo(
             description=_DESCRIPTION,
             features=features,
-            homepage=_HOMEPAGE,
-            license=_LICENSE,
             citation=_CITATION,
+            supervised_keys=None,
         )
 
     def _split_generators(self, dl_manager):
-        """Returns SplitGenerators."""
 
         data_dir = dl_manager.download_and_extract(_URL)
-        print("#"*50)
-        print(data_dir)
-        # data_dir = "./splits/"
 
+        print(data_dir)
+            
         return [
             datasets.SplitGenerator(
                 name=datasets.Split.TRAIN,
                 gen_kwargs={
-                    "base_path": data_dir,
-                    "filepath": data_dir + "/splits/train.json",
+                    "filepath_1": os.path.join(data_dir, "seq.in"),
+                    "filepath_2": os.path.join(data_dir, "seq.label"),
+                    "filepath_3": os.path.join(data_dir, "PxSLU_conll.txt"),
+                    "split": "train",
                 },
             ),
             datasets.SplitGenerator(
                 name=datasets.Split.VALIDATION,
                 gen_kwargs={
-                    "base_path": data_dir,
-                    "filepath": data_dir + "/splits/validation.json",
+                    "filepath_1": os.path.join(data_dir, "seq.in"),
+                    "filepath_2": os.path.join(data_dir, "seq.label"),
+                    "filepath_3": os.path.join(data_dir, "PxSLU_conll.txt"),
+                    "split": "validation",
                 },
             ),
             datasets.SplitGenerator(
                 name=datasets.Split.TEST,
                 gen_kwargs={
-                    "base_path": data_dir,
-                    "filepath": data_dir + "/splits/test.json",
+                    "filepath_1": os.path.join(data_dir, "seq.in"),
+                    "filepath_2": os.path.join(data_dir, "seq.label"),
+                    "filepath_3": os.path.join(data_dir, "PxSLU_conll.txt"),
+                    "split": "test",
                 },
             ),
         ]
 
-    def _generate_examples(self, base_path, filepath):
-
-        with open(filepath, encoding="utf-8") as f:
-
-            data = json.load(f)
-
-            for key, d in enumerate(data):
-
-                if str(d["icd-10"]) == "nan" or d["icd-10"].find("Plusieurs cas cliniques") != -1 or d["icd-10"].find("Aucune annotation") != -1:
-                    continue
-
-                yield key, {
-                    "identifier": d["identifier"],
-                    "title": d["title"],
-                    "clinical_case": d["clinical_case"],
-                    "topic": d["topic"],
-                    "keywords": d["keywords"],
-                    "domains": d["domain"],
-                    "collected_at": d["collected_at"],
-                    "published_at": d["published_at"],
-                    "source_url": d["source_url"],
-                    "source_name": d["source_name"],
-                    "license": d["license"],
-                    "figures_urls": d["figures"],
-                    "figures": [base_path + fg.lstrip(".") for fg in d["local_figures"]],
-                    "figures_paths": [base_path + fg.lstrip(".") for fg in d["local_figures"]],
-                    "icd-10": d["icd-10"],
-                }
+    def getTokenTags(self, document):
+
+        tokens = []
+        ner_tags = []
+
+        for pair in document.split("\n"):
+
+            if len(pair) <= 0:
+                continue
+
+            text, label = pair.split("\t")
+            tokens.append(text)
+            ner_tags.append(label)
+
+        return tokens, ner_tags
+
+    def _generate_examples(self, filepath_1, filepath_2, filepath_3, split):
+
+        key = 0
+        all_res = []
+    
+        f_seq_in = open(filepath_1, "r")
+        seq_in = f_seq_in.read().split("\n")
+        f_seq_in.close()
+
+        f_seq_label = open(filepath_2, "r")
+        seq_label = f_seq_label.read().split("\n")
+        f_seq_label.close()
+
+        f_in_ner = open(filepath_3, "r")
+        docs = f_in_ner.read().split("\n\n")
+        f_in_ner.close()
+
+        for idx, doc in enumerate(docs):
+
+            text = seq_in[idx]
+            label = seq_label[idx]
+
+            tokens, ner_tags = self.getTokenTags(docs[idx])
+
+            if len(text) <= 0 or len(label) <= 0:
+                continue
+
+            all_res.append({
+                "id": key,
+                "text": text,
+                "label": label,
+                "tokens": tokens,
+                "ner_tags": ner_tags,
+            })
+            
+            key += 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