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("")