Datasets:

joelniklaus
/

mapa

	import os
	from glob import glob
	from pathlib import Path

	import numpy as np
	import pandas as pd

	from web_anno_tsv import open_web_anno_tsv
	from web_anno_tsv.web_anno_tsv import ReadException, Annotation

	pd.set_option('display.max_colwidth', None)
	pd.set_option('display.max_columns', None)

	annotation_labels = {'ADDRESS': ['building', 'city', 'country', 'place', 'postcode', 'street', 'territory'],
	'AMOUNT': ['unit', 'value'],
	'DATE': ['year', 'standard abbreviation', 'month', 'day of the week', 'day', 'calender event'],
	'PERSON': ['age', 'email', 'ethnic category', 'family name', 'financial', 'given name – female',
	'given name – male',
	'health insurance number', 'id document number', 'initial name', 'marital status',
	'medical record number',
	'nationality', 'profession', 'role', 'social security number', 'title', 'url'],
	'ORGANISATION': [],
	'TIME': [],
	'VEHICLE': ['build year', 'colour', 'license plate number', 'model', 'type']}

	# make all labels upper case
	annotation_labels = {key.upper(): [label.upper() for label in labels] for key, labels in annotation_labels.items()}
	print(annotation_labels)
	print("coarse_grained:", list(annotation_labels.keys()))
	print("fine_grained:",
	[finegrained for finegrained in [finegrained_list for finegrained_list in annotation_labels.values()]])

	base_path = Path("extracted")

	# TODO future work can add these datasets too to make it larger
	special_paths = {
	"EL": ["EL/ANNOTATED_DATA/LEGAL/AREIOSPAGOS1/annotated/full_dataset"],
	"EN": ["EN/ANNOTATED_DATA/ADMINISTRATIVE-LEGAL/annotated/full_dataset"],
	"FR": ["FR/ANNOTATED_DATA/LEGAL/COUR_CASSATION1/annotated/full_dataset/Civil",
	"FR/ANNOTATED_DATA/LEGAL/COUR_CASSATION1/annotated/full_dataset/Commercial",
	"FR/ANNOTATED_DATA/LEGAL/COUR_CASSATION1/annotated/full_dataset/Criminal",
	"FR/ANNOTATED_DATA/LEGAL/COUR_CASSATION2/annotated/full_dataset",
	"FR/ANNOTATED_DATA/MEDICAL/CAS1/annotated/full_dataset"],
	"IT": ["IT/ANNOTATED_DATA/Corte_Suprema_di_Cassazione/annotated"],
	"MT": ["MT/ANNOTATED_DATA/ADMINISTRATIVE/annotated/full_dataset",
	"MT/ANNOTATED_DATA/GENERAL_NEWS/News_1/annotated/full_dataset",
	"MT/ANNOTATED_DATA/LEGAL/Jurisprudence_1/annotated/full_dataset"],
	}


	def get_path(language):
	return base_path / language / "ANNOTATED_DATA/EUR_LEX/annotated/full_dataset"


	def get_coarse_grained_for_fine_grained(label):
	for coarse_grained, fine_grained_set in annotation_labels.items():
	if label in fine_grained_set:
	return coarse_grained
	return None # raise ValueError(f"Did not find fine_grained label {label}")


	def is_fine_grained(label):
	for coarse_grained, fine_grained_set in annotation_labels.items():
	if label.upper() in fine_grained_set:
	return True
	return False


	def is_coarse_grained(label):
	return label.upper() in annotation_labels.keys()


	class HashableAnnotation(Annotation):
	def __init__(self, annotation):
	super()
	self.label = annotation.label
	self.start = annotation.start
	self.stop = annotation.stop
	self.text = annotation.text

	def __eq__(self, other):
	return self.label == other.label and self.start == other.start and self.stop == other.stop and self.text == other.text

	def __hash__(self):
	return hash(('label', self.label, 'start', self.start, 'stop', self.stop, 'text', self.text))


	def get_token_annotations(token, annotations):
	annotations = list(dict.fromkeys([HashableAnnotation(ann) for ann in annotations])) # remove duplicate annotations
	coarse_grained = "O"
	fine_grained = "o"
	for annotation in annotations:
	label = annotation.label
	# if token.start == annotation.start and token.stop == annotation.stop: # fine_grained annotation
	if token.start >= annotation.start and token.stop <= annotation.stop: # course_grained annotation
	# we don't support multilabel annotations for each token for simplicity.
	# So when a token already has an annotation for either coarse or fine grained, we don't assign new ones.
	if coarse_grained == "O" and is_coarse_grained(label):
	coarse_grained = label
	elif fine_grained == "o" and is_fine_grained(label):
	# some DATE are mislabeled as day but it is hard to correct this. So we ignore it
	fine_grained = label

	return coarse_grained.upper(), fine_grained.upper()


	def generate_IOB_labelset(series, casing_function):
	last_ent = ""
	new_series = []
	for ent in series:
	if ent in ["o", "O"]:
	ent_to_add = ent
	else:
	if ent != last_ent: # we are the first one
	ent_to_add = "B-" + ent
	else:
	ent_to_add = "I-" + ent
	new_series.append(casing_function(ent_to_add))
	last_ent = ent
	return new_series


	def get_annotated_sentence(result_sentence, sentence):
	result_sentence["tokens"] = []
	result_sentence["coarse_grained"] = []
	result_sentence["fine_grained"] = []
	for k, token in enumerate(sentence.tokens):
	coarse_grained, fine_grained = get_token_annotations(token, sentence.annotations)
	token = token.text.replace(u'\xa0', u' ').strip() # replace non-breaking spaces
	if token: # remove empty tokens (only consisted of whitespace before
	result_sentence["tokens"].append(token)
	result_sentence["coarse_grained"].append(coarse_grained)
	result_sentence["fine_grained"].append(fine_grained)
	result_sentence["coarse_grained"] = generate_IOB_labelset(result_sentence["coarse_grained"], str.upper)
	result_sentence["fine_grained"] = generate_IOB_labelset(result_sentence["fine_grained"], str.upper)
	return result_sentence


	languages = sorted([Path(file).stem for file in glob(str(base_path / "*"))])


	def parse_files(language):
	data_path = get_path(language.upper())
	result_sentences = []
	not_parsable_files = 0
	file_names = sorted(list(glob(str(data_path / "*.tsv"))))
	for file in file_names:
	try:
	with open_web_anno_tsv(file) as f:
	for i, sentence in enumerate(f):
	result_sentence = {"language": language, "type": "EUR-LEX",
	"file_name": Path(file).stem, "sentence_number": i}
	result_sentence = get_annotated_sentence(result_sentence, sentence)
	result_sentences.append(result_sentence)
	print(f"Successfully parsed file {file}")
	except ReadException as e:
	print(f"Could not parse file {file}")
	not_parsable_files += 1
	print("Not parsable files: ", not_parsable_files)
	return pd.DataFrame(result_sentences), not_parsable_files


	stats = []
	train_dfs, validation_dfs, test_dfs = [], [], []
	for language in languages:
	language = language.lower()
	print(f"Parsing language {language}")
	df, not_parsable_files = parse_files(language)
	file_names = df.file_name.unique()

	# df.coarse_grained.apply(lambda x: print(set(x)))

	# split by file_name
	num_fn = len(file_names)
	train_fn, validation_fn, test_fn = np.split(np.array(file_names), [int(.8 * num_fn), int(.9 * num_fn)])

	lang_train = df[df.file_name.isin(train_fn)]
	lang_validation = df[df.file_name.isin(validation_fn)]
	lang_test = df[df.file_name.isin(test_fn)]

	train_dfs.append(lang_train)
	validation_dfs.append(lang_validation)
	test_dfs.append(lang_test)

	lang_stats = {"language": language}

	lang_stats["# train files"] = len(train_fn)
	lang_stats["# validation files"] = len(validation_fn)
	lang_stats["# test files"] = len(test_fn)

	lang_stats["# train sentences"] = len(lang_train.index)
	lang_stats["# validation sentences"] = len(lang_validation.index)
	lang_stats["# test sentences"] = len(lang_test.index)

	stats.append(lang_stats)

	stat_df = pd.DataFrame(stats)
	print(stat_df.to_markdown(index=False))

	train = pd.concat(train_dfs)
	validation = pd.concat(validation_dfs)
	test = pd.concat(test_dfs)

	df = pd.concat([train, validation, test])
	print(f"The final coarse grained tagset (in IOB notation) is the following: "
	f"`{list(df.coarse_grained.explode().unique())}`")
	print(f"The final fine grained tagset (in IOB notation) is the following: "
	f"`{list(df.fine_grained.explode().unique())}`")


	# save splits
	def save_splits_to_jsonl(config_name):
	# save to jsonl files for huggingface
	if config_name: os.makedirs(config_name, exist_ok=True)
	train.to_json(os.path.join(config_name, "train.jsonl"), lines=True, orient="records", force_ascii=False)
	validation.to_json(os.path.join(config_name, "validation.jsonl"), lines=True, orient="records", force_ascii=False)
	test.to_json(os.path.join(config_name, "test.jsonl"), lines=True, orient="records", force_ascii=False)


	save_splits_to_jsonl("")