Update scripts to use data.zip instead of local data.

DEFT2021.py

@@ -1,15 +1,18 @@
 import os
-import re
-import ast
-import json
 import random
+
 from pathlib import Path
-from itertools import product
-from dataclasses import dataclass
-from typing import Dict, List, Tuple
+import numpy as np
 
 import datasets
-import numpy as np
+
+_DESCRIPTION = """\
+ddd
+"""
+
+_HOMEPAGE = "ddd"
+
+_LICENSE = "unknown"
 
 _CITATION = """\
 @inproceedings{grouin-etal-2021-classification,
@@ -29,18 +32,13 @@ _CITATION = """\
 }
 """
 
-_DESCRIPTION = """\
-ddd
-"""
-
-_HOMEPAGE = "ddd"
-
-_LICENSE = "unknown"
-
 _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"
@@ -51,7 +49,7 @@ class DEFT2021(datasets.GeneratorBasedBuilder):
     ]
 
     def _info(self):
-        
+
         if self.config.name.find("cls") != -1:
 
             features = datasets.Features(
@@ -77,7 +75,13 @@ class DEFT2021(datasets.GeneratorBasedBuilder):
                     "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'],
+                            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'
+                            ],
                         )
                     ),
                 }
@@ -94,12 +98,8 @@ class DEFT2021(datasets.GeneratorBasedBuilder):
 
     def _split_generators(self, dl_manager):
 
-        if self.config.data_dir is None:
-            raise ValueError("This is a local dataset. Please pass the data_dir kwarg to load_dataset.")
-        
-        else:
-            data_dir = self.config.data_dir
-            
+        data_dir = dl_manager.download_and_extract(_URL).rstrip("/")
+
         return [
             datasets.SplitGenerator(
                 name=datasets.Split.TRAIN,
@@ -126,52 +126,52 @@ class DEFT2021(datasets.GeneratorBasedBuilder):
 
     def remove_prefix(self, a: str, prefix: str) -> str:
         if a.startswith(prefix):
-            a = a[len(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"] = []
@@ -180,30 +180,30 @@ class DEFT2021(datasets.GeneratorBasedBuilder):
                 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])
+                        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 = {
@@ -211,16 +211,16 @@ class DEFT2021(datasets.GeneratorBasedBuilder):
                         "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],
@@ -229,9 +229,9 @@ class DEFT2021(datasets.GeneratorBasedBuilder):
                     "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
@@ -239,136 +239,136 @@ class DEFT2021(datasets.GeneratorBasedBuilder):
             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)
-    
+                text = text.replace(i, ' ' + i)
+
             for i in rep_after:
-                text = text.replace(i, i+' ')
-    
+                text = text.replace(i, i + ' ')
+
             for i in rep_both:
-                text = text.replace(i, ' '+i+' ')
-    
+                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 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,
@@ -379,7 +379,7 @@ class DEFT2021(datasets.GeneratorBasedBuilder):
                             'id': a['entity_id'],
                             'text': a['text'][o],
                         })
-    
+
             res = {
                 'id': ex['document_id'],
                 'document_id': ex['document_id'],
@@ -387,117 +387,117 @@ class DEFT2021(datasets.GeneratorBasedBuilder):
                 '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)]
-    
+
+                    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)]
-    
+
+                        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
-            
+            ner_tags = ['O'] * nb_tokens
+
             for slct in selected_annotations:
-    
-                for x in range(slct['token_start'], slct['token_end']+1, 1):
-    
+
+                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']
+                            ner_tags[x-1] = slct['label'] + '-' + slct['id']
                     else:
                         if ner_tags[x] == 'O':
-                            ner_tags[x] = slct['label']+'-'+slct['id']
-    
+                            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)
+                        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)
+                            ner_tags_IOB2.append('I-' + current_label)
                         else:
-                            ner_tags_IOB2.append('B-'+current_label)
+                            ner_tags_IOB2.append('B-' + current_label)
                     else:
-                        ner_tags_IOB2.append('B-'+current_label)
-    
+                        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
 
+        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'])]
-            
+
+            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]
-                                    })
+
+                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]
-                                    }) 
-        
+                    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 = {}
@@ -509,7 +509,7 @@ class DEFT2021(datasets.GeneratorBasedBuilder):
             else:
                 split_eval = 'test'
 
-            path_labels = Path(data_dir)  / 'evaluations' / f"ref-{split_eval}-deft2021.txt"
+            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:
 
@@ -525,7 +525,7 @@ class DEFT2021(datasets.GeneratorBasedBuilder):
 
                         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]]
 
@@ -533,7 +533,7 @@ class DEFT2021(datasets.GeneratorBasedBuilder):
 
                 for guid, txt_file in enumerate(sorted(ann_path.glob("*.txt"))):
 
-                    ann_file = txt_file.with_suffix("").name.split('.')[0]+'.ann'
+                    ann_file = txt_file.with_suffix("").name.split('.')[0] + '.ann'
 
                     if ann_file in doc_specialities_:
 
@@ -562,14 +562,14 @@ class DEFT2021(datasets.GeneratorBasedBuilder):
                         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":
@@ -580,7 +580,7 @@ class DEFT2021(datasets.GeneratorBasedBuilder):
                     allowed_ids = list(validation)
 
                 for r in all_res.values():
-                    if r["document_id"]+'.txt' in allowed_ids:
+                    if r["document_id"] + '.txt' in allowed_ids:
                         yield r["id"], r
 
         elif self.config.name.find("ner") != -1:
@@ -618,7 +618,7 @@ class DEFT2021(datasets.GeneratorBasedBuilder):
                     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'],
@@ -636,5 +636,5 @@ class DEFT2021(datasets.GeneratorBasedBuilder):
                     allowed_ids = list(test)
 
                 for r in all_res:
-                    if r["document_id"]+'.txt' in allowed_ids:
+                    if r["document_id"] + '.txt' in allowed_ids:
                         yield r["id"], r

data.zip

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:84276b07f43c98f2874d342c08af9346bb3920a5dd4b2deeccd9314ca09dbbdd
-size 2046495
+oid sha256:36633ad2d4d1c399dd906c7ba1a11aa352f49aa9e67b7b02414521d965f93bbd
+size 1990713