Datasets:

DrBenchmark
/

DEFT2021

@@ -1,641 +0,0 @@
-import os
-import random
-from typing import Dict, List
-from pathlib import Path
-import numpy as np
-import datasets
-_DESCRIPTION = """\
-ddd
-"""
-_HOMEPAGE = "ddd"
-_LICENSE = "unknown"
-_CITATION = r"""\
-@inproceedings{grouin-etal-2021-classification,
-    title = "Classification de cas cliniques et {\'e}valuation automatique de r{\'e}ponses d{'}{\'e}tudiants : pr{\'e}sentation de la campagne {DEFT} 2021 (Clinical cases classification and automatic evaluation of student answers : Presentation of the {DEFT} 2021 Challenge)",
-    author = "Grouin, Cyril  and
-      Grabar, Natalia  and
-      Illouz, Gabriel",
-    booktitle = "Actes de la 28e Conf{\'e}rence sur le Traitement Automatique des Langues Naturelles. Atelier D{\'E}fi Fouille de Textes (DEFT)",
-    month = "6",
-    year = "2021",
-    address = "Lille, France",
-    publisher = "ATALA",
-    url = "https://aclanthology.org/2021.jeptalnrecital-deft.1",
-    pages = "1--13",
-    abstract = "Le d{\'e}fi fouille de textes (DEFT) est une campagne d{'}{\'e}valuation annuelle francophone. Nous pr{\'e}sentons les corpus et baselines {\'e}labor{\'e}es pour trois t{\^a}ches : (i) identifier le profil clinique de patients d{\'e}crits dans des cas cliniques, (ii) {\'e}valuer automatiquement les r{\'e}ponses d{'}{\'e}tudiants sur des questionnaires en ligne (Moodle) {\`a} partir de la correction de l{'}enseignant, et (iii) poursuivre une {\'e}valuation de r{\'e}ponses d{'}{\'e}tudiants {\`a} partir de r{\'e}ponses d{\'e}j{\`a} {\'e}valu{\'e}es par l{'}enseignant. Les r{\'e}sultats varient de 0,394 {\`a} 0,814 de F-mesure sur la premi{\`e}re t{\^a}che (7 {\'e}quipes), de 0,448 {\`a} 0,682 de pr{\'e}cision sur la deuxi{\`e}me (3 {\'e}quipes), et de 0,133 {\`a} 0,510 de pr{\'e}cision sur la derni{\`e}re (3 {\'e}quipes).",
-    language = "French",
-}
-"""
-_SPECIALITIES = ['immunitaire', 'endocriniennes', 'blessures', 'chimiques', 'etatsosy', 'nutritionnelles', 'infections', 'virales', 'parasitaires', 'tumeur', 'osteomusculaires', 'stomatognathique', 'digestif', 'respiratoire', 'ORL', 'nerveux', 'oeil', 'homme', 'femme', 'cardiovasculaires', 'hemopathies', 'genetique', 'peau']
-_LABELS_BASE = ['anatomie', 'date', 'dose', 'duree', 'examen', 'frequence', 'mode', 'moment', 'pathologie', 'sosy', 'substance', 'traitement', 'valeur']
-_URL = "data.zip"
-class DEFT2021(datasets.GeneratorBasedBuilder):
-    DEFAULT_CONFIG_NAME = "ner"
-    BUILDER_CONFIGS = [
-        datasets.BuilderConfig(name="cls", version="1.0.0", description="DEFT 2021 corpora - Classification task"),
-        datasets.BuilderConfig(name="ner", version="1.0.0", description="DEFT 2021 corpora - Named-entity recognition task"),
-    ]
-    def _info(self):
-        if self.config.name.find("cls") != -1:
-            features = datasets.Features(
-                {
-                    "id": datasets.Value("string"),
-                    "document_id": datasets.Value("string"),
-                    "text": datasets.Value("string"),
-                    "specialities": datasets.Sequence(
-                        datasets.features.ClassLabel(names=_SPECIALITIES),
-                    ),
-                    "specialities_one_hot": datasets.Sequence(
-                        datasets.Value("float"),
-                    ),
-                }
-            )
-        elif self.config.name.find("ner") != -1:
-            features = datasets.Features(
-                {
-                    "id": datasets.Value("string"),
-                    "document_id": datasets.Value("string"),
-                    "tokens": datasets.Sequence(datasets.Value("string")),
-                    "ner_tags": datasets.Sequence(
-                        datasets.features.ClassLabel(
-                            names=[
-                                'O', 'B-anatomie', 'I-anatomie', 'B-date', 'I-date', 'B-dose',
-                                'I-dose', 'B-duree', 'I-duree', 'B-examen', 'I-examen', 'B-frequence',
-                                'I-frequence', 'B-mode', 'I-mode', 'B-moment', 'I-moment',
-                                'B-pathologie', 'I-pathologie', 'B-sosy', 'I-sosy', 'B-substance',
-                                'I-substance', 'B-traitement', 'I-traitement', 'B-valeur', 'I-valeur'
-                            ],
-                        )
-                    ),
-                }
-            )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            supervised_keys=None,
-            homepage=_HOMEPAGE,
-            license=str(_LICENSE),
-            citation=_CITATION,
-        )
-    def _split_generators(self, dl_manager):
-        data_dir = dl_manager.download_and_extract(_URL).rstrip("/")
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "data_dir": data_dir,
-                    "split": "train",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={
-                    "data_dir": data_dir,
-                    "split": "validation",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={
-                    "data_dir": data_dir,
-                    "split": "test",
-                },
-            ),
-        ]
-    def remove_prefix(self, a: str, prefix: str) -> str:
-        if a.startswith(prefix):
-            a = a[len(prefix):]
-        return a
-    def parse_brat_file(self, txt_file: Path, annotation_file_suffixes: List[str] = None, parse_notes: bool = False) -> Dict:
-        example = {}
-        example["document_id"] = txt_file.with_suffix("").name
-        with txt_file.open() as f:
-            example["text"] = f.read()
-        # If no specific suffixes of the to-be-read annotation files are given - take standard suffixes
-        # for event extraction
-        if annotation_file_suffixes is None:
-            annotation_file_suffixes = [".a1", ".a2", ".ann"]
-        if len(annotation_file_suffixes) == 0:
-            raise AssertionError(
-                "At least one suffix for the to-be-read annotation files should be given!"
-            )
-        ann_lines = []
-        for suffix in annotation_file_suffixes:
-            annotation_file = txt_file.with_suffix(suffix)
-            if annotation_file.exists():
-                with annotation_file.open() as f:
-                    ann_lines.extend(f.readlines())
-        example["text_bound_annotations"] = []
-        example["events"] = []
-        example["relations"] = []
-        example["equivalences"] = []
-        example["attributes"] = []
-        example["normalizations"] = []
-        if parse_notes:
-            example["notes"] = []
-        for line in ann_lines:
-            line = line.strip()
-            if not line:
-                continue
-            if line.startswith("T"):  # Text bound
-                ann = {}
-                fields = line.split("\t")
-                ann["id"] = fields[0]
-                ann["type"] = fields[1].split()[0]
-                ann["offsets"] = []
-                span_str = self.remove_prefix(fields[1], (ann["type"] + " "))
-                text = fields[2]
-                for span in span_str.split(";"):
-                    start, end = span.split()
-                    ann["offsets"].append([int(start), int(end)])
-                # Heuristically split text of discontiguous entities into chunks
-                ann["text"] = []
-                if len(ann["offsets"]) > 1:
-                    i = 0
-                    for start, end in ann["offsets"]:
-                        chunk_len = end - start
-                        ann["text"].append(text[i:chunk_len + i])
-                        i += chunk_len
-                        while i < len(text) and text[i] == " ":
-                            i += 1
-                else:
-                    ann["text"] = [text]
-                example["text_bound_annotations"].append(ann)
-            elif line.startswith("E"):
-                ann = {}
-                fields = line.split("\t")
-                ann["id"] = fields[0]
-                ann["type"], ann["trigger"] = fields[1].split()[0].split(":")
-                ann["arguments"] = []
-                for role_ref_id in fields[1].split()[1:]:
-                    argument = {
-                        "role": (role_ref_id.split(":"))[0],
-                        "ref_id": (role_ref_id.split(":"))[1],
-                    }
-                    ann["arguments"].append(argument)
-                example["events"].append(ann)
-            elif line.startswith("R"):
-                ann = {}
-                fields = line.split("\t")
-                ann["id"] = fields[0]
-                ann["type"] = fields[1].split()[0]
-                ann["head"] = {
-                    "role": fields[1].split()[1].split(":")[0],
-                    "ref_id": fields[1].split()[1].split(":")[1],
-                }
-                ann["tail"] = {
-                    "role": fields[1].split()[2].split(":")[0],
-                    "ref_id": fields[1].split()[2].split(":")[1],
-                }
-                example["relations"].append(ann)
-            # '*' seems to be the legacy way to mark equivalences,
-            # but I couldn't find any info on the current way
-            # this might have to be adapted dependent on the brat version
-            # of the annotation
-            elif line.startswith("*"):
-                ann = {}
-                fields = line.split("\t")
-                ann["id"] = fields[0]
-                ann["ref_ids"] = fields[1].split()[1:]
-                example["equivalences"].append(ann)
-            elif line.startswith("A") or line.startswith("M"):
-                ann = {}
-                fields = line.split("\t")
-                ann["id"] = fields[0]
-                info = fields[1].split()
-                ann["type"] = info[0]
-                ann["ref_id"] = info[1]
-                if len(info) > 2:
-                    ann["value"] = info[2]
-                else:
-                    ann["value"] = ""
-                example["attributes"].append(ann)
-            elif line.startswith("N"):
-                ann = {}
-                fields = line.split("\t")
-                ann["id"] = fields[0]
-                ann["text"] = fields[2]
-                info = fields[1].split()
-                ann["type"] = info[0]
-                ann["ref_id"] = info[1]
-                ann["resource_name"] = info[2].split(":")[0]
-                ann["cuid"] = info[2].split(":")[1]
-                example["normalizations"].append(ann)
-            elif parse_notes and line.startswith("#"):
-                ann = {}
-                fields = line.split("\t")
-                ann["id"] = fields[0]
-                ann["text"] = fields[2] if len(fields) == 3 else "<BB_NULL_STR>"
-                info = fields[1].split()
-                ann["type"] = info[0]
-                ann["ref_id"] = info[1]
-                example["notes"].append(ann)
-        return example
-    def _to_source_example(self, brat_example: Dict) -> Dict:
-        source_example = {
-            "document_id": brat_example["document_id"],
-            "text": brat_example["text"],
-        }
-        source_example["entities"] = []
-        for entity_annotation in brat_example["text_bound_annotations"]:
-            entity_ann = entity_annotation.copy()
-            # Change id property name
-            entity_ann["entity_id"] = entity_ann["id"]
-            entity_ann.pop("id")
-            # Add entity annotation to sample
-            source_example["entities"].append(entity_ann)
-        return source_example
-    def convert_to_prodigy(self, json_object, list_label):
-        def prepare_split(text):
-            rep_before = ['?', '!', ';', '*']
-            rep_after = ['’', "'"]
-            rep_both = ['-', '/', '[', ']', ':', ')', '(', ',', '.']
-            for i in rep_before:
-                text = text.replace(i, ' ' + i)
-            for i in rep_after:
-                text = text.replace(i, i + ' ')
-            for i in rep_both:
-                text = text.replace(i, ' ' + i + ' ')
-            text_split = text.split()
-            punctuations = [',', '.']
-            for j in range(0, len(text_split)-1):
-                if j - 1 >= 0 and j + 1 <= len(text_split) - 1 and text_split[j-1][-1].isdigit() and text_split[j+1][0].isdigit():
-                    if text_split[j] in punctuations:
-                        text_split[j-1:j+2] = [''.join(text_split[j-1:j+2])]
-            text = ' '.join(text_split)
-            return text
-        new_json = []
-        for ex in [json_object]:
-            text = prepare_split(ex['text'])
-            tokenized_text = text.split()
-            list_spans = []
-            for a in ex['entities']:
-                for o in range(len(a['offsets'])):
-                    text_annot = prepare_split(a['text'][o])
-                    offset_start = a['offsets'][o][0]
-                    offset_end = a['offsets'][o][1]
-                    nb_tokens_annot = len(text_annot.split())
-                    txt_offsetstart = prepare_split(ex['text'][:offset_start])
-                    nb_tokens_before_annot = len(txt_offsetstart.split())
-                    token_start = nb_tokens_before_annot
-                    token_end = token_start + nb_tokens_annot - 1
-                    if a['type'] in list_label:
-                        list_spans.append({
-                            'start': offset_start,
-                            'end': offset_end,
-                            'token_start': token_start,
-                            'token_end': token_end,
-                            'label': a['type'],
-                            'id': a['entity_id'],
-                            'text': a['text'][o],
-                        })
-            res = {
-                'id': ex['document_id'],
-                'document_id': ex['document_id'],
-                'text': ex['text'],
-                'tokens': tokenized_text,
-                'spans': list_spans
-            }
-            new_json.append(res)
-        return new_json
-    def convert_to_hf_format(self, json_object):
-        dict_out = []
-        for i in json_object:
-            # Filter annotations to keep the longest annotated spans when there is nested annotations
-            selected_annotations = []
-            if 'spans' in i:
-                for idx_j, j in enumerate(i['spans']):
-                    len_j = int(j['end']) - int(j['start'])
-                    range_j = [l for l in range(int(j['start']), int(j['end']), 1)]
-                    keep = True
-                    for idx_k, k in enumerate(i['spans'][idx_j+1:]):
-                        len_k = int(k['end']) - int(k['start'])
-                        range_k = [l for l in range(int(k['start']), int(k['end']), 1)]
-                        inter = list(set(range_k).intersection(set(range_j)))
-                        if len(inter) > 0 and len_j < len_k:
-                            keep = False
-                    if keep:
-                        selected_annotations.append(j)
-            # Create list of labels + id to separate different annotation and prepare IOB2 format
-            nb_tokens = len(i['tokens'])
-            ner_tags = ['O'] * nb_tokens
-            for slct in selected_annotations:
-                for x in range(slct['token_start'], slct['token_end'] + 1, 1):
-                    if i['tokens'][x] not in slct['text']:
-                        if ner_tags[x-1] == 'O':
-                            ner_tags[x-1] = slct['label'] + '-' + slct['id']
-                    else:
-                        if ner_tags[x] == 'O':
-                            ner_tags[x] = slct['label'] + '-' + slct['id']
-            # Make IOB2 format
-            ner_tags_IOB2 = []
-            for idx_l, label in enumerate(ner_tags):
-                if label == 'O':
-                    ner_tags_IOB2.append('O')
-                else:
-                    current_label = label.split('-')[0]
-                    current_id = label.split('-')[1]
-                    if idx_l == 0:
-                        ner_tags_IOB2.append('B-' + current_label)
-                    elif current_label in ner_tags[idx_l-1]:
-                        if current_id == ner_tags[idx_l-1].split('-')[1]:
-                            ner_tags_IOB2.append('I-' + current_label)
-                        else:
-                            ner_tags_IOB2.append('B-' + current_label)
-                    else:
-                        ner_tags_IOB2.append('B-' + current_label)
-            dict_out.append({
-                'id': i['id'],
-                'document_id': i['document_id'],
-                "ner_tags": ner_tags_IOB2,
-                "tokens": i['tokens'],
-            })
-        return dict_out
-    def split_sentences(self, json_o):
-        """
-            Split each document in sentences to fit the 512 maximum tokens of BERT.
-        """
-        final_json = []
-        for i in json_o:
-            ind_punc = [index for index, value in enumerate(i['tokens']) if value == '.'] + [len(i['tokens'])]
-            for index, value in enumerate(ind_punc):
-                if index == 0:
-                    final_json.append({
-                        'id': i['id'] + '_' + str(index),
-                        'document_id': i['document_id'],
-                        'ner_tags': i['ner_tags'][:value+1],
-                        'tokens': i['tokens'][:value+1]
-                    })
-                else:
-                    prev_value = ind_punc[index-1]
-                    final_json.append({
-                        'id': i['id'] + '_' + str(index),
-                        'document_id': i['document_id'],
-                        'ner_tags': i['ner_tags'][prev_value+1:value+1],
-                        'tokens': i['tokens'][prev_value+1:value+1]
-                    })
-        return final_json
-    def _generate_examples(self, data_dir, split):
-        if self.config.name.find("cls") != -1:
-            all_res = {}
-            key = 0
-            if split == 'train' or split == 'validation':
-                split_eval = 'train'
-            else:
-                split_eval = 'test'
-            path_labels = Path(data_dir) / 'evaluations' / f"ref-{split_eval}-deft2021.txt"
-            with open(os.path.join(data_dir, 'distribution-corpus.txt')) as f_dist:
-                doc_specialities_ = {}
-                with open(path_labels) as f_spec:
-                    doc_specialities = [line.strip() for line in f_spec.readlines()]
-                    for raw in doc_specialities:
-                        raw_split = raw.split('\t')
-                        if len(raw_split) == 3 and raw_split[0] in doc_specialities_:
-                            doc_specialities_[raw_split[0]].append(raw_split[1])
-                        elif len(raw_split) == 3 and raw_split[0] not in doc_specialities_:
-                            doc_specialities_[raw_split[0]] = [raw_split[1]]
-                ann_path = Path(data_dir) / "DEFT-cas-cliniques"
-                for guid, txt_file in enumerate(sorted(ann_path.glob("*.txt"))):
-                    ann_file = txt_file.with_suffix("").name.split('.')[0] + '.ann'
-                    if ann_file in doc_specialities_:
-                        res = {}
-                        res['document_id'] = txt_file.with_suffix("").name
-                        with txt_file.open() as f:
-                            res["text"] = f.read()
-                        specialities = doc_specialities_[ann_file]
-                        # Empty one hot vector
-                        one_hot = [0.0 for i in _SPECIALITIES]
-                        # Fill up the one hot vector
-                        for s in specialities:
-                            one_hot[_SPECIALITIES.index(s)] = 1.0
-                        all_res[res['document_id']] = {
-                            "id": str(key),
-                            "document_id": res['document_id'],
-                            "text": res["text"],
-                            "specialities": specialities,
-                            "specialities_one_hot": one_hot,
-                        }
-                        key += 1
-                distribution = [line.strip() for line in f_dist.readlines()]
-                random.seed(4)
-                train = [raw.split('\t')[0] for raw in distribution if len(raw.split('\t')) == 4 and raw.split('\t')[3] == 'train 2021']
-                random.shuffle(train)
-                random.shuffle(train)
-                random.shuffle(train)
-                train, validation = np.split(train, [int(len(train)*0.7096)])
-                test = [raw.split('\t')[0] for raw in distribution if len(raw.split('\t')) == 4 and raw.split('\t')[3] == 'test 2021']
-                if split == "train":
-                    allowed_ids = list(train)
-                elif split == "test":
-                    allowed_ids = list(test)
-                elif split == "validation":
-                    allowed_ids = list(validation)
-                for r in all_res.values():
-                    if r["document_id"] + '.txt' in allowed_ids:
-                        yield r["id"], r
-        elif self.config.name.find("ner") != -1:
-            all_res = []
-            key = 0
-            with open(os.path.join(data_dir, 'distribution-corpus.txt')) as f_dist:
-                distribution = [line.strip() for line in f_dist.readlines()]
-                random.seed(4)
-                train = [raw.split('\t')[0] for raw in distribution if len(raw.split('\t')) == 4 and raw.split('\t')[3] == 'train 2021']
-                random.shuffle(train)
-                random.shuffle(train)
-                random.shuffle(train)
-                train, validation = np.split(train, [int(len(train)*0.73)])
-                test = [raw.split('\t')[0] for raw in distribution if len(raw.split('\t')) == 4 and raw.split('\t')[3] == 'test 2021']
-                ann_path = Path(data_dir) / "DEFT-cas-cliniques"
-                for guid, txt_file in enumerate(sorted(ann_path.glob("*.txt"))):
-                    brat_example = self.parse_brat_file(txt_file, parse_notes=True)
-                    source_example = self._to_source_example(brat_example)
-                    prod_format = self.convert_to_prodigy(source_example, _LABELS_BASE)
-                    hf_format = self.convert_to_hf_format(prod_format)
-                    hf_split = self.split_sentences(hf_format)
-                    for h in hf_split:
-                        if len(h['tokens']) > 0 and len(h['ner_tags']) > 0:
-                            all_res.append({
-                                "id": str(key),
-                                "document_id": h['document_id'],
-                                "tokens": h['tokens'],
-                                "ner_tags": h['ner_tags'],
-                            })
-                            key += 1
-                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["document_id"] + '.txt' in allowed_ids:
-                        yield r["id"], r