prepare_legal_data.py

# No chunks, one doc per line

# remove new lines, etc.
# create a corpus of min 200-400 GB ==> ~100B tokens
# max file size: 4GB because of huggingface
# validation set: ~100M tokens ==> 200-400MB

import glob
import json
import multiprocessing

import tqdm
import os
import re
from multiprocessing import Pool

from datasets import load_dataset
from tokenizers import normalizers

_LANGUAGES = ['bg', 'cs', 'da', 'de', 'el', 'en', 'es', 'et', 'fi', 'fr', 'ga', 'hr',
              'hu', 'it', 'lt', 'lv', 'mt', 'nl', 'pl', 'pt', 'ro', 'sk', 'sl', 'sv']
_DOMAIN_TYPES = ['legislation', 'caselaw', 'contracts', 'other', 'wikipedia']

custom_normalizer = normalizers.NFKD()

VALIDATION_SIZE = 1_000  # ~1MB per configuration ==> some low-resource configs will only have a validation file

filtered_dir = os.path.join('data', 'filtered')
os.makedirs(filtered_dir, exist_ok=True)


def preprocess_dataset(languages=None, domain_types=None):
    lang_type_datasets = []
    # set defaults if they are not set
    if languages is None:
        languages = _LANGUAGES
    if domain_types is None:
        domain_types = _DOMAIN_TYPES

    for LANG in languages:
        for DOMAIN_TYPE in domain_types:
            try:
                if DOMAIN_TYPE == 'wikipedia':
                    # get from EU_Wikipedias
                    dataset = load_dataset("joelito/EU_Wikipedias", date="20221120", language=LANG,
                                           split='train', streaming=True, use_auth_token=True)
                else:
                    # get from Multi_Legal_Pile
                    dataset = load_dataset("joelito/Multi_Legal_Pile", f'{LANG}_{DOMAIN_TYPE}',
                                           split='train', streaming=True, use_auth_token=True)
                dataset = dataset.shuffle(seed=42, buffer_size=10_000)
                print(f'Found data for `{DOMAIN_TYPE}` in language `{LANG}`.')
            except:
                print(f'There is no data for `{DOMAIN_TYPE}` in language `{LANG}`.')
                continue
            lang_type_datasets.append(dataset)
    return lang_type_datasets


def write_samples(dataset_number):
    dataset, dataset_name = dataset_number
    if len(dataset_name.split('_')) == 1:  # wikipedia
        language = dataset_name.split('.')[1]
        domain_type = "wikipedia"
        dataset_name = f"{language}_{domain_type}"  # reformat the config name so that we have wikipedia in the name
    else:
        language, domain_type = dataset_name.split('_')
    total_count, temp_count, all_samples, file_number = 0, 0, 0, 0
    out_file = open_file(dataset_name, file_number, "validation")  # we save the first examples to the validation set
    print(f'Processing for dataset {dataset_name} started!')
    # Read each document
    for sample in tqdm.tqdm(dataset):
        try:
            text = normalize_text(sample['text'])
            if "validation" in out_file.name and temp_count > VALIDATION_SIZE:
                # if we are saving to eval, and we have enough samples in the eval set, switch to train
                out_file.close()
                temp_count = 0
                out_file = open_file(dataset_name, file_number, "train")
            # on average approx. 2GB per file, compresses (with xz) to around ~500MB (xz: ~75% compression ratio)
            if "train" in out_file.name and temp_count > 500_000: # err on the small side of the file size
                # if we are saving to train, and we reached the max size per file, switch to the next file
                out_file.close()
                file_number += 1
                temp_count = 0
                out_file = open_file(dataset_name, file_number, "train")
            # if the text is usable for pretraining, save it
            if is_text_usable(text):
                jurisdiction = sample.get('jurisdiction', "N/A")  # set defaults for wikipedia
                type = sample.get("type", "wikipedia")  # set defaults for wikipedia
                entry = {"language": sample["language"], "type": type, "jurisdiction": jurisdiction, "text": text}
                out_file.write(json.dumps(entry) + '\n')
                total_count += 1
                temp_count += 1
            all_samples += 1
        except:
            continue

    try:
        out_file.close()
    except:
        pass

    print(f'Processing for dataset {dataset_name} finished with {total_count}/{all_samples}!')
    return


def is_text_usable(text):
    # Compute percentage of alphabetical characters in relation to full sequence length
    punctuation = '!\"#$%&\'()*+,\-\./:;<=>?@\[\\\]\^_`{\|}~'
    alpha_text = re.sub(rf'[{punctuation}\d]', '', text)  # remove numbers and punctuation
    alpha_percent = len(alpha_text) / len(text)
    # Compute total chunk length
    text_length = len(text.split())
    # Ignore sequences with more than 30% numbers or short sequences (less than 64 tokens)
    return alpha_percent > 0.7 and text_length > 64


def normalize_text(text):
    # Normalize the document
    text = custom_normalizer.normalize_str(text)
    # Replace multiple newline and whitespaces
    return re.sub(r'(\n )+', r'\n ', re.sub(r'( *[\n\r]+ *)+', r'\n ', re.sub(r'[\t ]+', r' ', text)))


def open_file(dataset_name, file_number, split):
    return open(os.path.join(filtered_dir, f'{dataset_name}_{split}_{file_number}.jsonl'), 'w', encoding='utf8')


def clean_and_filter_documents():
    # Load all datasets across languages and types
    lang_type_datasets = preprocess_dataset(languages=None, domain_types=None)
    # also pass in dataset_name
    lang_type_datasets = [(dataset, dataset.config_name) for dataset in lang_type_datasets]
    print(lang_type_datasets)

    # Launch pool to preprocess datasets in parallel
    max_num_processes = min(multiprocessing.cpu_count() - 2, len(lang_type_datasets))
    num_processes = max(max_num_processes, 1)
    print(f'Launching a Pool with maximum {num_processes} processes...')
    with Pool(num_processes) as pool:
        pool.map(write_samples, lang_type_datasets)

    # Compress datasets
    print(f"Compressing datasets at {filtered_dir}")
    # Do this at the end because we use multithreading
    for path in glob.glob(os.path.join(filtered_dir, '*.jsonl')):
        print(f"Compressing {path}")
        os.system(f'xz -zkf -T0 {path}')  # -TO to use multithreading
        print(f"Removing uncompressed file at {path}")
        os.system(f'rm {path}')  # remove uncompressed file to save space

    print(f"Finished preparing legal data")



if __name__ == '__main__':
    """
    Run with 
    export PYTHONPATH=. && python prepare_legal_data.py | tee prepare_legal_data.log 
    """
    clean_and_filter_documents()

# Get locally
# def get_file(LANG, DOMAIN_TYPE, split, number):
#    base_folder = "data/mlm_dataset/chunks_512"
#    return f'{base_folder}/{LANG}_{DOMAIN_TYPE}_{split}_{number}.jsonl.xz'

# files = [get_file(LANG, DOMAIN_TYPE, 'train', i) for i in range(1, 5)]
# files = [f for f in files if os.path.exists(f)] # make sure the file actually exists
# dataset = load_dataset("json", data_files={'train': files}, split='train', streaming=True)

# TODO write dataset cards for chunked, eu wikipedia and filtered dataset