Update MANTRAGSC.py

MANTRAGSC.py

@@ -13,19 +13,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import re
-import ast
-import json
+# pip install xmltodict
+
 import random
 from pathlib import Path
 from itertools import product
 from dataclasses import dataclass
 from typing import Dict, List, Tuple
 
-import datasets
-
+import xmltodict
 import numpy as np
 
+import datasets
+
 _CITATION = """\
 @article{10.1093/jamia/ocv037,
 	author = {Kors, Jan A and Clematide, Simon and Akhondi,
@@ -69,7 +69,7 @@ _HOMEPAGE = "https://biosemantics.erasmusmc.nl/index.php/resources/mantra-gsc"
 
 _LICENSE = "CC_BY_4p0"
 
-_URL = "http://biosemantics.org/MantraGSC/Mantra-GSC.zip"
+_URL = "https://files.ifi.uzh.ch/cl/mantra/gsc/GSC-v1.1.zip"
 
 _LANGUAGES_2 = {
 	"es": "Spanish",
@@ -82,7 +82,7 @@ _LANGUAGES_2 = {
 _DATASET_TYPES = {
 	"emea": "EMEA",
 	"medline": "Medline",
-	"patents": "Patents",
+	"patents": "Patent",
 }
 
 @dataclass
@@ -118,23 +118,26 @@ class MANTRAGSC(datasets.GeneratorBasedBuilder):
 
 	def _info(self):
 
-		if self.config.name.find("emea") != -1:
-			names = ['O', 'DISO', 'CHEM|PHEN', 'DEVI', 'PHEN', 'PROC', 'OBJC', 'ANAT', 'LIVB', 'CHEM', 'PHYS']
-		elif self.config.name.find("medline") != -1:
-			names = ['O', 'DISO', 'GEOG', 'DEVI', 'Manufactured Object', 'PHEN', 'PROC', 'Research Device', 'OBJC', 'Mental or Behavioral Dysfunction', 'Research Activity', 'ANAT', 'LIVB', 'CHEM', 'PHYS']
-		elif self.config.name.find("patents") != -1:
-			names = ['O', 'PROC', 'DISO', 'LIVB', 'PHYS', 'PHEN', 'ANAT', 'OBJC', 'Amino Acid, Peptide, or Protein|Enzyme|Receptor', 'DEVI', 'CHEM']
+		# if self.config.name.find("emea") != -1:
+		# 	names = ['O', 'DISO', 'CHEM|PHEN', 'DEVI', 'PHEN', 'PROC', 'OBJC', 'ANAT', 'LIVB', 'CHEM', 'PHYS']
+		# elif self.config.name.find("medline") != -1:
+		# 	names = ['O', 'DISO', 'GEOG', 'DEVI', 'Manufactured Object', 'PHEN', 'PROC', 'Research Device', 'OBJC', 'Mental or Behavioral Dysfunction', 'Research Activity', 'ANAT', 'LIVB', 'CHEM', 'PHYS']
+		# elif self.config.name.find("patents") != -1:
+		# 	names = ['O', 'PROC', 'DISO', 'LIVB', 'PHYS', 'PHEN', 'ANAT', 'OBJC', 'Amino Acid, Peptide, or Protein|Enzyme|Receptor', 'DEVI', 'CHEM']
 		
 		features = datasets.Features(
 			{
 				"id": datasets.Value("string"),
-				"document_id": datasets.Value("string"),
+				# "document_id": datasets.Value("string"),
 				"tokens": [datasets.Value("string")],
 				"ner_tags": datasets.Sequence(
-					datasets.features.ClassLabel(
-						names = names,
-					)
+					datasets.Value("string")
 				),
+				# "ner_tags": datasets.Sequence(
+				# 	datasets.features.ClassLabel(
+				# 		names = names,
+				# 	)
+				# ),
 			}
 		)
 
@@ -148,11 +151,11 @@ class MANTRAGSC(datasets.GeneratorBasedBuilder):
 
 	def _split_generators(self, dl_manager):
 
+		language, dataset_type = self.config.name.split("_")
+		
 		data_dir = dl_manager.download_and_extract(_URL)
 
-		data_dir = Path(data_dir) / "Mantra-GSC"
-
-		language, dataset_type = self.config.name.split("_")
+		data_dir = Path(data_dir) / "GSC-v1.1" / f"{_DATASET_TYPES[dataset_type]}_GSC_{language}_man.xml"
 
 		return [
 			datasets.SplitGenerator(
@@ -184,328 +187,83 @@ class MANTRAGSC(datasets.GeneratorBasedBuilder):
 			),
 		]
 
-	def convert_to_prodigy(self, json_object):
-
-		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 = []
+	def _generate_examples(self, data_dir, language, dataset_type, split):
+		"""Yields examples as (key, example) tuples."""
 
-		for ex in [json_object]:
+		with open(data_dir) as fd:
+			doc = xmltodict.parse(fd.read())
 
-			text = prepare_split(ex['text'])
+		all_res = []
 
-			tokenized_text = text.split()
+		for d in doc["Corpus"]["document"]:
 
-			list_spans = []
+			# print(d)
+			# print()
 
-			cpt = 0
+			if type(d["unit"]) != type(list()):
+				d["unit"] = [d["unit"]]
 
-			for a in ex['entities']:
+			for u in d["unit"]:
 
-				for o in range(len(a['offsets'])):
+				text = u["text"]
 
-					text_annot = prepare_split(a['text'][o])
+				if "e" in u.keys():
 
-					offset_start = a['offsets'][o][0]
-					offset_end = a['offsets'][o][1]
+					if type(u["e"]) != type(list()):
+						u["e"] = [u["e"]]
+					
+					tags = [{
+						"label": current["@grp"].upper(),
+						"offset_start": int(current["@offset"]),
+						"offset_end": int(current["@offset"]) + int(current["@len"]),
+					} for current in u["e"]]
 
-					nb_tokens_annot = len(text_annot.split())
+				else:
+					tags = []
 
-					txt_offsetstart = prepare_split(ex['text'][:offset_start])
+				_tokens = text.split(" ")
+				tokens = []
+				for i, t in enumerate(_tokens):
 
-					nb_tokens_before_annot = len(txt_offsetstart.split())
+					concat = " ".join(_tokens[0:i+1])
 
-					token_start = nb_tokens_before_annot
-					token_end = token_start + nb_tokens_annot - 1
+					offset_start = len(concat) - len(t)
+					offset_end = len(concat)
 
-					list_spans.append({
-						'start': offset_start,
-						'end': offset_end,
-						'token_start': token_start,
-						'token_end': token_end,
-						'label': a['type'],
-						'id': ex['document_id'] + "_" + str(cpt),
-						'text': a['text'][o],
+					tokens.append({
+						"token": t,
+						"offset_start": offset_start,
+						"offset_end": offset_end,
 					})
 
-					cpt += 1
-
-			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):
-		"""
-		Le format prends en compte le multilabel en faisant une concaténation avec "_" entre chaque label
-		"""
-		
-		dict_out = []
-		
-		for i in json_object:
-
-			nb_tokens = len(i['tokens'])
-			
-			ner_tags = ['O']*nb_tokens
-			
-			if 'spans' in i:  
-
-				for j in i['spans']:
-
-					for x in range(j['token_start'], j['token_end']+1, 1):
-
-						if i['tokens'][x] not in j['text'] and i['tokens'][x] != "Matériovigilance":
-
-							if ner_tags[x-1] == 'O':
-								ner_tags[x-1] = j['label']
-							else:
-								pass
-						else:
-							if ner_tags[x] == 'O':
-								ner_tags[x] = j['label']
-							else:
-								# Commenter la ligne et mettre pass si on veut prendre qu'un label par token
-								pass
-
-			dict_out.append({
-				'id': i['id'],
-				'document_id': i['document_id'],
-				"ner_tags": ner_tags,
-				"tokens": i['tokens'],
-			})
-		
-		return dict_out
-
-	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):
-
-		example = {}
-		example["document_id"] = txt_file.with_suffix("").name
-		with txt_file.open() as f:
-			example["text"] = f.read()
-
-		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]
+				ner_tags = ["O" for o in tokens]
 
-				ann["type"], ann["trigger"] = fields[1].split()[0].split(":")
+				for tag in tags:
 
-				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)
+					for idx, token in enumerate(tokens):
 
-				example["events"].append(ann)
+						# Range du tag
+						rtok = range(token["offset_start"], token["offset_end"]+1)
+						rtag = range(tag["offset_start"], tag["offset_end"]+1)
 
-			elif line.startswith("R"):
-				ann = {}
-				fields = line.split("\t")
+						# Check if the ranges are overlapping
+						if bool(set(rtok) & set(rtag)):
 
-				ann["id"] = fields[0]
-				ann["type"] = fields[1].split()[0]
+							# if ner_tags[idx] != "O" and ner_tags[idx] != tag['label']:
+							# 	print(f"{token} - currently: {ner_tags[idx]} - after: {tag['label']}")
+							
+							ner_tags[idx] = tag["label"]
 
-				ann["head"] = {
-					"role": fields[1].split()[1].split(":")[0],
-					"ref_id": fields[1].split()[1].split(":")[1],
+				obj = {
+					"id": u["@id"],
+					"tokens": [t["token"] for t in tokens],
+					"ner_tags": ner_tags,
 				}
-				ann["tail"] = {
-					"role": fields[1].split()[2].split(":")[0],
-					"ref_id": fields[1].split()[2].split(":")[1],
-				}
-
-				example["relations"].append(ann)
-
-			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()
+				# print(obj)
+				# print("*"*50)
 
-				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 _generate_examples(self, data_dir, language, dataset_type, split):
-		"""Yields examples as (key, example) tuples."""
-
-		data_dir = data_dir / f"{_LANGUAGES_2[language]}"
-
-		if dataset_type in ["patents", "emea"]:
-			data_dir = data_dir / f"{_DATASET_TYPES[dataset_type]}_ec22-cui-best_man"
-		else:
-			# Medline
-			if language != "en":
-				data_dir = (
-					data_dir
-					/ f"{_DATASET_TYPES[dataset_type]}_EN_{language.upper()}_ec22-cui-best_man"
-				)
-			else:
-				data_dir = [
-					data_dir
-					/ f"{_DATASET_TYPES[dataset_type]}_EN_{_lang.upper()}_ec22-cui-best_man"
-					for _lang in _LANGUAGES_2
-					if _lang != "en"
-				]
-
-		if not isinstance(data_dir, list):
-			data_dir: List[Path] = [data_dir]
-
-		raw_files = [raw_file for _dir in data_dir for raw_file in _dir.glob("*.txt")]
-
-		all_res = []
-
-		for i, raw_file in enumerate(raw_files):
-			brat_example = self.parse_brat_file(raw_file, parse_notes=True)
-			source_example = self._to_source_example(brat_example)
-
-			prod_format = self.convert_to_prodigy(source_example)
-
-			hf_format = self.convert_to_hf_format(prod_format)[0]
-			all_res.append(hf_format)
-	
+				all_res.append(obj)
+		
 		ids = [r["id"] for r in all_res]
 
 		random.seed(4)
@@ -526,39 +284,3 @@ class MANTRAGSC(datasets.GeneratorBasedBuilder):
 			identifier = r["id"]
 			if identifier in allowed_ids:
 				yield identifier, r 
-		
-	def _to_source_example(self, brat_example):
-
-		source_example = {
-			"document_id": brat_example["document_id"],
-			"text": brat_example["text"],
-		}
-
-		source_example["entities"] = []
-
-		for entity_annotation, ann_notes in zip(brat_example["text_bound_annotations"], brat_example["notes"]):
-			
-			entity_ann = entity_annotation.copy()
-
-			entity_ann["entity_id"] = entity_ann["id"]
-			entity_ann.pop("id")
-
-			# Get values from annotator notes
-			assert entity_ann["entity_id"] == ann_notes["ref_id"]
-			notes_values = ast.literal_eval(ann_notes["text"])
-			
-			if len(notes_values) == 4:
-				cui, preferred_term, semantic_type, semantic_group = notes_values
-			else:
-				preferred_term, semantic_type, semantic_group = notes_values
-				cui = entity_ann["type"]
-			
-			entity_ann["cui"] = cui
-			entity_ann["preferred_term"] = preferred_term
-			entity_ann["semantic_type"] = semantic_type
-			entity_ann["type"] = semantic_group
-			entity_ann["normalized"] = [{"db_name": "UMLS", "db_id": cui}]
-
-			source_example["entities"].append(entity_ann)
-
-		return source_example