Update DEFT2021

DEFT2021

@@ -36,7 +36,7 @@ _SPECIALITIES = ['immunitaire', 'endocriniennes', 'blessures', 'chimiques', 'eta
 
 class DEFT2021(datasets.GeneratorBasedBuilder):
 
-    DEFAULT_CONFIG_NAME = "source"
+    DEFAULT_CONFIG_NAME = "ner"
 
     BUILDER_CONFIGS = [
         datasets.BuilderConfig(name="source", version="1.0.0", description="DEFT 2021 corpora"),
@@ -44,19 +44,36 @@ class DEFT2021(datasets.GeneratorBasedBuilder):
 
     def _info(self):
 
-        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"),
-                ),
-            }
-        )
+		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,
@@ -99,81 +116,511 @@ class DEFT2021(datasets.GeneratorBasedBuilder):
             ),
         ]
 
-    def _generate_examples(self, data_dir, split):
-
-        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,
+    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
 
-                    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)])
+    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'])]
             
-            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
+            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:
+      
+                      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)
+      
+              print("train", len(train))
+              print("validation", len(validation))
+              print("test", len(test))
+      
+              for r in all_res:
+                  if r["document_id"]+'.txt' in allowed_ids:
+                      yield r["id"], r