Datasets:
Tasks:
Token Classification
Modalities:
Text
Formats:
json
Sub-tasks:
named-entity-recognition
Size:
10K - 100K
License:
| 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("") | |