ptrdvn/opus_lid_filtered

What this dataset is

This dataset is a filtered version of the MaLA-LM/mala-opus-dedup-2410 dataset after having all texts with incorrect language codes filtered out of it.

To do this, we use the cis-lmu/glotlid language ID model, predict the top probability language for both texts (source and target) and discard a row in which either text has a different language code to its original label.

How this dataset was made

from tqdm.auto import tqdm
from datasets import load_dataset, Dataset
import fasttext
from huggingface_hub import hf_hub_download, HfApi, HfFileSystem
import os
import time
from glob import glob

lid_model_path = hf_hub_download(repo_id="cis-lmu/glotlid", filename="model.bin")
lid_model = fasttext.load_model(lid_model_path)

def get_lang_preds(source_text, target_text):
    source_pred = lid_model.predict(source_text, 1)
    target_pred = lid_model.predict(target_text, 1)

    source_label = source_pred[0][0].replace("__label__", "")
    source_conf = source_pred[1][0]
    target_label = target_pred[0][0].replace("__label__", "")
    target_conf = target_pred[1][0]

    return {
        "source_predlang_id": source_label,
        "source_predlang_conf": source_conf,
        "target_predlang_id": target_label,
        "target_predlang_conf": target_conf
    }

def filter_file(file_path, num_proc=24):
    time.sleep(2.0)
    temp_file = "./temp.jsonl"
    os.system(f"wget {get_url(file_path)} -O {temp_file}")
    ds = load_dataset("json", data_files={"train": temp_file}, split="train")
    ds = ds.map(lambda x: get_lang_preds(x["source_text"], x["target_text"]), num_proc=num_proc)
    ds = ds.filter(lambda x: bool(x["source_lang"] == x["source_predlang_id"]) and bool(x["target_lang"] == x["target_predlang_id"]), num_proc=num_proc)
    return ds

PARQUET_FOLDER = "./datasets/"
api = HfApi(token="hf_YOUR_HF_TOKEN")

def upload_folder():
    api.upload_folder(
        folder_path=PARQUET_FOLDER,
        path_in_repo="data/", # Upload to a specific folder
        repo_id="ptrdvn/opus_lid_filtered",
        repo_type="dataset",
    )

def save_parquet(ds, file_path):
    ds.to_parquet(
        PARQUET_FOLDER + "/".join(file_path.split("/")[-2:])[:-len(".jsonl")] + ".parquet"
    )

get_url = lambda file_path: f"https://huggingface.co/datasets/MaLA-LM/mala-opus-dedup-2410/resolve/main/" + "/".join(file_path.split("/")[-2:])

def main():

    fs = HfFileSystem()

    lang_pairs = sorted(fs.ls("datasets/MaLA-LM/mala-opus-dedup-2410", detail=False))
    prev_lang_pairs = sorted(fs.ls("datasets/ptrdvn/opus_lid_filtered/data", detail=False))
    last_lang_pair = prev_lang_pairs[-1].split("/")[-1]
    print(last_lang_pair)
    lang_pairs = [x for x in lang_pairs if x.split("/")[-1] >= last_lang_pair]

    data_amounts = []

    for lang_pair in lang_pairs:
        file_paths = fs.ls(lang_pair,detail=False)
        num_uploads = 0
        for file_path in file_paths:
            ds = filter_file(file_path)
            if len(ds) > 0:
                save_parquet(ds, file_path)

        # Upload to huggingface if there are more than 20 parquet files to mitigate rate limits
        if len(glob("./datasets/*/*.parquet")) > 20:
            print("Sleeping for 10 seconds")
            time.sleep(10)
            print("Uploading folder", file_path.split("/")[-2])
            upload_folder()
            os.system("rm -rf " + PARQUET_FOLDER)

        os.system("rm -rf ~/.cache/huggingface/datasets")
        print("Finished with", file_path.split("/")[-2] + ".parquet")

    upload_folder()

while True:
    try:
        main()
    except Exception as e:
        print("MAIN LOOP ERROR")
        print(e)
        time.sleep(180)
        upload_folder()