Add dataset creation scripts

calculate_kenlm_perplexity.py

@@ -0,0 +1,26 @@
+import datasets
+import kenlm
+
+kenlm_model = kenlm.Model("kenlm_5gram_fi.bin")
+
+
+def get_perplexity(example):
+    """Get perplexity of text field."""
+    example["perplexity_kenlm"] = int(kenlm_model.perplexity(example["text"]))
+    return example
+
+
+dataset = datasets.load_from_disk("/researchdisk/mc4_3.1.0_fi_cleaned")
+
+# TRAIN SPLIT PERPLEXITY
+dataset["train"] = dataset["train"].map(
+    get_perplexity, num_proc=64
+)
+
+# VALIDATION SPLIT PERPLEXITY
+dataset["validation"] = dataset["validation"].map(
+    get_perplexity, num_proc=64
+)
+
+# SAVE DATASET
+dataset.save_to_disk("/researchdisk/mc4_3.1.0_fi_cleaned", num_proc=32)

clean_data.py

@@ -0,0 +1,93 @@
+import datasets
+from clean_funcs import clean_text
+from filter_stats_funcs import filter_stats
+
+fi_mc4 = datasets.load_from_disk("/researchdisk/mc4_3.1.0_fi")
+print(fi_mc4)
+
+min_alphabet_ratio = 0.75
+max_upper_ratio = 0.10
+max_number_ratio = 0.05
+min_pred_lang_percentage = 0.95
+
+# TRAIN SPLIT
+print(f"Original dataset train rows {fi_mc4['train'].num_rows}")
+fi_mc4["train"] = fi_mc4["train"].map(
+    clean_text, num_proc=64, batched=False
+)
+
+fi_train_only_longer = fi_mc4["train"].filter(
+    lambda example: len(example["text"].split()) >= 20, num_proc=64
+)
+print(f"Only longer texts dataset train rows {fi_train_only_longer.num_rows}")
+
+fi_train_only_longer = fi_train_only_longer.map(
+    filter_stats, num_proc=64, batched=False
+)
+
+fi_train_cleaned = fi_train_only_longer.filter(
+    lambda example: example["alphabet_ratio"] > min_alphabet_ratio
+    and example["upper_ratio"] < max_upper_ratio
+    and example["number_ratio"] < max_number_ratio
+    and example["predicted_lang"] == "__label__fi"
+    and example["predicted_lang_percentage"] > min_pred_lang_percentage,
+    num_proc=64,
+)
+print(f"Final cleaned dataset train rows {fi_train_cleaned.num_rows}")
+
+# VAL SPLIT
+print(f"Original dataset val rows {fi_mc4['validation'].num_rows}")
+fi_mc4["validation"] = fi_mc4["validation"].map(
+    clean_text, num_proc=32, batched=False
+)
+
+fi_val_only_longer = fi_mc4["validation"].filter(
+    lambda example: len(example["text"].split()) >= 20, num_proc=32
+)
+print(f"Only longer texts dataset val rows {fi_val_only_longer.num_rows}")
+
+fi_val_only_longer = fi_val_only_longer.map(filter_stats, num_proc=32, batched=False)
+
+fi_val_cleaned = fi_val_only_longer.filter(
+    lambda example: example["alphabet_ratio"] > min_alphabet_ratio
+    and example["upper_ratio"] < max_upper_ratio
+    and example["number_ratio"] < max_number_ratio
+    and example["predicted_lang"] == "__label__fi"
+    and example["predicted_lang_percentage"] > min_pred_lang_percentage,
+    num_proc=32,
+)
+print(f"Final cleaned dataset val rows {fi_val_cleaned.num_rows}")
+
+# SAVE TO DISK
+fi_train_cleaned = fi_train_cleaned.remove_columns(
+    [
+        "alphabet_len",
+        "number_len",
+        "upper_len",
+        "total_len",
+        "predicted_lang",
+        "predicted_lang_percentage",
+        "alphabet_ratio",
+        "number_ratio",
+        "upper_ratio",
+    ]
+)
+fi_val_cleaned = fi_val_cleaned.remove_columns(
+    [
+        "alphabet_len",
+        "number_len",
+        "upper_len",
+        "total_len",
+        "predicted_lang",
+        "predicted_lang_percentage",
+        "alphabet_ratio",
+        "number_ratio",
+        "upper_ratio",
+    ]
+)
+
+fi_mc4_cleaned = datasets.DatasetDict()
+fi_mc4_cleaned["train"] = fi_train_cleaned
+fi_mc4_cleaned["validation"] = fi_val_cleaned
+
+fi_mc4_cleaned.save_to_disk("/researchdisk/mc4_3.1.0_fi_cleaned", num_proc=32)

clean_funcs.py

@@ -0,0 +1,116 @@
+import re
+import unicodedata
+from functools import reduce
+from itertools import groupby
+from string import punctuation
+
+url_regex = re.compile(r"((www\.[^\s]+)|(https?://[^\s]+)|(http?://[^\s]+))")
+control_char_regex = re.compile(r"[\r\n\t]+")
+phone_number_regex = re.compile("\(?\+?\d[\s\d()-]{5,}\d")
+finnish_social_id_regex = re.compile("\d{6}[-+Aa]\d{3}[a-zA-Z0-9]")
+email_regex = re.compile(r"[\w.+-]+@[\w-]+\.[\w.-]+")
+
+
+def clean_text(example) -> str:
+    data_preprocessing_funcs = [
+        _replace_identity,
+        _replace_phone_number,
+        _replace_url,
+        _replace_email,
+        _fix_html,
+        _standardise_punc,
+        _remove_unicode_symbols,
+        _remove_control_char,
+        _remove_remaining_control_chars,
+        _remove_multiple_punctuation,
+        _remove_multi_space,
+    ]
+    return reduce(lambda x, y: y(x["text"]), data_preprocessing_funcs, example)
+
+
+def _standardise_punc(text: str) -> str:
+    transl_table = dict([(ord(x), ord(y)) for x, y in zip("‘’´“”–-", "'''\"\"--")])
+    text_mod = text.translate(transl_table)
+    text_mod = re.sub(r"[^a-zA-Z0-9À-ÿ .,'%&€$=@+;<>/()!?%:-]", " ", text_mod)
+    return {"text": text_mod}
+
+
+def _remove_control_char(text: str) -> str:
+    text_mod = re.sub(control_char_regex, " ", text)
+    return {"text": text_mod}
+
+
+def _remove_remaining_control_chars(text: str) -> str:
+    text_mod = "".join(ch for ch in text if unicodedata.category(ch)[0] != "C")
+    return {"text": text_mod}
+
+
+def _remove_multi_space(text: str) -> str:
+    text_mod = " ".join([txt for txt in text.split(" ") if txt and txt != ""])
+    return {"text": text_mod}
+
+
+def _remove_unicode_symbols(text: str) -> str:
+    text_mod = "".join(ch for ch in text if unicodedata.category(ch)[0:2] != "So")
+    return {"text": text_mod}
+
+
+def _replace_url(text: str) -> str:
+    filler = ""
+    occ = text.count("www.") + text.count("http:") + text.count("https:")
+    text_mod = text
+    for _ in range(occ):
+        # replace other urls by filler
+        text_mod = re.sub(url_regex, filler, text_mod)
+        text_mod = " ".join(text_mod.split())
+    return {"text": text_mod}
+
+
+def _fix_html(text: str) -> str:
+    text_mod = (
+        text.replace("#39;", "'")
+        .replace("amp;", "&")
+        .replace("#146;", "'")
+        .replace("nbsp;", " ")
+        .replace("\\n", "\n")
+        .replace("quot;", "'")
+        .replace("<br />", "\n")
+        .replace('\\"', '"')
+        .replace(" @.@ ", ".")
+        .replace(" @-@ ", "-")
+        .replace("...", " …")
+    )
+    return {"text": text_mod}
+
+
+def _replace_phone_number(text: str) -> str:
+    text_mod = re.sub(phone_number_regex, " ", text)
+    return {"text": text_mod}
+
+
+def _replace_identity(text: str) -> str:
+    text_mod = re.sub(finnish_social_id_regex, " ", text)
+    return {"text": text_mod}
+
+
+def _replace_email(text: str) -> str:
+    text_mod = re.sub(email_regex, " ", text)
+    return {"text": text_mod}
+
+
+def _remove_news_tags(text: str) -> str:
+    text_mod = re.sub(r"(<[A-Z].+?>)|(</[A-Z].+?>)", " ", text)
+    return {"text": text_mod}
+
+
+def _remove_multiple_punctuation(text: str) -> str:
+    text_mod = re.sub(r"\b(\w+)( \1\b)+", r"\1", text)
+    punc = set(punctuation)
+    newtext = []
+    for k, g in groupby(text_mod):
+        if k in punc:
+            newtext.append(k)
+        else:
+            newtext.extend(g)
+    text_mod = "".join(newtext)
+    return {"text": text_mod}

create_dataset.py

@@ -0,0 +1,28 @@
+import datasets
+
+features = datasets.Features(
+    {
+        "source": datasets.Value(dtype="string", id=None),
+        "id": datasets.Value(dtype="string", id=None),
+        "text": datasets.Value(dtype="string", id=None),
+        "added": datasets.Value(dtype="string", id=None),
+        "timestamp": datasets.Value(dtype="timestamp[s]", id=None),
+        "metadata": {"url": datasets.Value(dtype="string", id=None)},
+    }
+)
+dataset = datasets.load_dataset(
+    "json",
+    data_files={
+        "train": "fi_processed/c4-fi.*.json",
+        "validation": "fi_processed/c4-fi-validation*.json",
+    },
+    features=features,
+    cache_dir="/researchdisk/datasets_cache",
+    num_proc=96,
+)
+
+dataset = dataset.flatten()
+dataset = dataset.rename_column("metadata.url", "url")
+dataset = dataset.remove_columns(["source", "id", "added"])
+print(dataset)
+dataset.save_to_disk("/researchdisk/mc4_3.1.0_fi", num_proc=96)

deduplicate.py

@@ -0,0 +1,72 @@
+# adapted from: https://github.com/huggingface/transformers/blob/master/examples/research_projects/codeparrot/scripts/preprocessing.py
+
+import datasets
+
+
+def get_hash(example):
+    """Get hash of text field."""
+    return {"hash": hash(example["text"])}
+
+
+def check_uniques(example, uniques):
+    """Check if current hash is still in set of unique hashes and remove if true."""
+    if example["hash"] in uniques:
+        uniques.remove(example["hash"])
+        return True
+    else:
+        return False
+
+
+def filter(example, uniques):
+    """Filter dataset with unique values."""
+    if not check_uniques(example, uniques):
+        return False
+    else:
+        return True
+
+
+dataset = datasets.load_from_disk("/researchdisk/mc4_3.1.0_fi_cleaned")
+
+# TRAIN SPLIT DEDUPLICATION
+
+print(f"Size of original dataset train: {len(dataset['train'])}")
+
+dataset["train"] = dataset["train"].map(get_hash, num_proc=96)
+
+# Deduplicate hashes
+uniques = set(dataset["train"].unique("hash"))
+frac = len(uniques) / len(dataset["train"])
+print(f"Fraction of duplicates: {1-frac:.2%}")
+
+# Deduplicate data
+dataset_train_deduplicated = dataset["train"].filter(
+    filter, fn_kwargs={"uniques": uniques}, num_proc=64
+)
+print(f"Size of filtered dataset train: {len(dataset_train_deduplicated)}")
+
+# VALIDATION SPLIT DEDUPLICATION
+
+print(f"Size of original dataset valid: {len(dataset['validation'])}")
+
+dataset["validation"] = dataset["validation"].map(get_hash, num_proc=96)
+
+# Deduplicate hashes
+uniques = set(dataset["validation"].unique("hash"))
+frac = len(uniques) / len(dataset["validation"])
+print(f"Fraction of duplicates: {1-frac:.2%}")
+
+# Deduplicate data
+dataset_valid_deduplicated = dataset["validation"].filter(
+    filter, fn_kwargs={"uniques": uniques}, num_proc=32
+)
+print(f"Size of filtered dataset valid: {len(dataset_valid_deduplicated)}")
+
+# SAVE DEDUPLICATED DATASET
+dataset_train_deduplicated = dataset_train_deduplicated.remove_columns(["hash"])
+dataset_valid_deduplicated = dataset_valid_deduplicated.remove_columns(["hash"])
+
+fi_mc4_cleaned = datasets.DatasetDict()
+fi_mc4_cleaned["train"] = dataset_train_deduplicated
+fi_mc4_cleaned["validation"] = dataset_valid_deduplicated
+
+fi_mc4_cleaned.save_to_disk("/researchdisk/mc4_3.1.0_fi_cleaned", num_proc=32)

filter_stats_funcs.py

@@ -0,0 +1,62 @@
+import re
+import fasttext
+from functools import reduce
+
+FASTTEXT_MODEL_PATH = "/researchdisk/lid.176.bin"
+fasttext_model = fasttext.load_model(FASTTEXT_MODEL_PATH)
+
+
+def filter_stats(batch):
+    filter_stats_funcs = [
+        _count_alphabet,
+        _count_numbers,
+        _count_upper,
+        _count_str_len,
+        _predict_lang,
+        _calculate_alphabet_ratio,
+        _calculate_number_ratio,
+        _calculate_upper_ratio,
+    ]
+    return reduce(lambda x, y: y(x), filter_stats_funcs, batch)
+
+
+def _count_alphabet(batch):
+    batch["alphabet_len"] = len(re.findall(r"[äÄöÖåÅa-zA-Z]", batch["text"]))
+    return batch
+
+
+def _count_numbers(batch):
+    batch["number_len"] = len(re.findall(r"[0-9]", batch["text"]))
+    return batch
+
+
+def _count_upper(batch):
+    batch["upper_len"] = len(re.findall(r"[ÄÖÅA-Z]", batch["text"]))
+    return batch
+
+
+def _count_str_len(batch):
+    batch["total_len"] = len(batch["text"])
+    return batch
+
+
+def _predict_lang(batch):
+    pred = fasttext_model.predict(batch["text"])
+    batch["predicted_lang"] = pred[0][0]
+    batch["predicted_lang_percentage"] = float(pred[1][0])
+    return batch
+
+
+def _calculate_alphabet_ratio(batch):
+    batch["alphabet_ratio"] = int(batch["alphabet_len"]) / int(batch["total_len"])
+    return batch
+
+
+def _calculate_number_ratio(batch):
+    batch["number_ratio"] = int(batch["number_len"]) / int(batch["total_len"])
+    return batch
+
+
+def _calculate_upper_ratio(batch):
+    batch["upper_ratio"] = int(batch["upper_len"]) / int(batch["total_len"])
+    return batch

jq_process_loaded_mc4_files.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+
+# Set the source directory containing the JSON files
+source_dir="multilingual"
+
+# Set the destination directory to save the modified JSON files
+destination_dir="fi_processed"
+
+# Create the destination directory if it doesn't exist
+mkdir -p "$destination_dir"
+
+# Process each train split JSON file in the source directory
+for file in "$source_dir"/c4-fi.*.json; do
+  # Extract the filename without the directory path and extension
+  filename=$(basename -- "$file")
+  filename="${filename%.*}"
+
+  # Remove the "lang" key from the JSON file using jq because it had errors while trying to load into huggingface datasets
+  jq -c 'del(.lang)' "$file" > "$destination_dir/$filename.json"
+done
+
+# Process each validation split JSON file in the source directory
+for file in "$source_dir"/c4-fi-validation*.json; do
+  # Extract the filename without the directory path and extension
+  filename=$(basename -- "$file")
+  filename="${filename%.*}"
+
+  # Remove the "lang" key from the JSON file using jq because it had errors while trying to load into huggingface datasets
+  jq -c 'del(.lang)' "$file" > "$destination_dir/$filename.json"
+done

kenlm_5gram_fi.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:24509a40ab1450810907aad8d803c43073ab1b7773991f2cf4973648fe380eac
+size 6123664435

load_mc4_3.1.0_fi.sh

@@ -0,0 +1,6 @@
+GIT_LFS_SKIP_SMUDGE=1 git clone --depth 1 --branch mC4_3.1.0 https://huggingface.co/datasets/allenai/c4
+cd c4
+git lfs pull --include "multilingual/c4-fi.*.json.gz"
+git lfs pull --include "multilingual/c4-fi-validation*.json.gz"
+gunzip multilingual/c4-fi.*.json.gz
+gunzip multilingual/c4-fi-validation*.json.gz