Datasets:

sabilmakbar
/

sea_wiki

@@ -1,414 +0,0 @@
-# %%
-'''
-Script on Cleansing Wikipedia Data that has been extracted from extract_raw_wiki_data.py
-'''
-#core functionality modules
-import os, gc
-import logging
-import argparse
-import warnings
-from functools import partial
-#text preprocess modules
-import re
-import urllib
-from xml.etree import ElementTree as ET
-#dataset related modules
-import numpy as np
-import pandas as pd
-### MODULES DEFINITION ###
-#create custom type-checking of incoming ArgParse
-def argparse_bool_check(value: str):
-    #cast str with value like float into actual float
-    try:
-        value = float(value)
-    #can't be parsed as float, keep as it is
-    except ValueError:
-        pass
-    #cast float-like value (incl int) into str
-    if isinstance(value, float) and int(value) == value:
-        value = str(int(value))
-    #raise ArgumentTypeError if the value isn't in string already
-    else:
-        if not isinstance(value, str):
-            raise argparse.ArgumentTypeError(f"Not the correct value (args: {value})! Expected is cast-able to '1' or '0' or already in string. Please rectify!")
-    #check for these combinations of values
-    if value.lower() in ("yes", "true", "t", "y", "1"):
-        return True
-    elif value.lower() in ("no", "false", "f", "n", "0"):
-        return False
-    else:
-        raise argparse.ArgumentTypeError(f"Value Error! Not the correct value (args: {value})! Please rectify!")
-def text_processing_args_checker(value: str):
-    if value not in ["all", "text", "title", "neither"]:
-        raise argparse.ArgumentTypeError(f"Value Error! Not the correct value (args: {value})! Please rectify!")
-    else:
-        return value
-def set_logger():
-    # Set up the logger
-    logging.basicConfig(
-        level=logging.INFO,  # Set the desired logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
-        format='%(asctime)s [%(levelname)s]: %(message)s',  # Customize the log message format
-        datefmt='%Y-%m-%d %H:%M:%S'  # Customize the date/time format
-    )
-    # Create a file handler to write logs into a file
-    file_handler = logging.FileHandler('app.log')
-    # Set the log level for the file handler
-    file_handler.setLevel(logging.INFO)
-    # Create a formatter for the file handler (customize the log format for the file)
-    file_formatter = logging.Formatter('%(asctime)s [%(levelname)s]: %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
-    file_handler.setFormatter(file_formatter)
-    logger = logging.getLogger("Wiki Dataset Generation")
-    logger.addHandler(file_handler)
-    return logger
-#wrapper fn of text-cleansing
-def text_cleansing_wrapper(fn, exception_class_names = []):
-    #ensure caught exception class names passed to decorator is a list (if provided)
-    if not isinstance(exception_class_names, list):
-        raise TypeError("Exception Class Name for Wrapper is not a list!")
-    #ensure all values of caught exception class name list is a string
-    if not all([isinstance(val, str) for val in exception_class_names]):
-        raise ValueError("Found an element of Exception Class Name for Wrapper that is not a string!")
-    #lowercase all exception class name
-    exception_class_names = [val.lower() for val in exception_class_names]
-    if len(exception_class_names) == 0:
-        warnings.warn("The wrapper receives 0 `exception_class_names` to be warned! Will return the function value with its input!")
-    def text_fn_wrapper(text: str, *args, **kwargs):
-        try:
-            return fn(text, *args, **kwargs)
-        except Exception as e:
-            _exc_name = type(e).__name__
-            if _exc_name.lower() not in exception_class_names and len(exception_class_names)>0:
-                raise Exception(f"Exception Occured of {_exc_name} in {fn.__name__}!") from e
-            else:
-                _followup_msg = "Returning the input as it is..."
-                _text_warn = f"An exception of {_exc_name} occured in {fn.__name__}! {_followup_msg}"
-                warnings.warn(_text_warn)
-                return text
-    return text_fn_wrapper
-#create html tags cleanser of a given text
-partial_decorator = partial(text_cleansing_wrapper, exception_class_names=["parseerror"])
-@partial_decorator
-def remove_html_tags(text: str):
-    #extracted from "https://stackoverflow.com/a/9662410", w/ additional decorator of error handler
-    return (''.join(ET.fromstring(text).itertext())).strip()
-#create url decoder of text
-@text_cleansing_wrapper
-def decode_url(text: str):
-    # return (urllib.parse.unquote(text)).encode('utf8', errors='ignore').decode().strip()
-    return (urllib.parse.unquote(text)).strip()
-#create encoder check of text
-@text_cleansing_wrapper
-def check_text_by_encoder(text: str, encoder: str="utf8"):
-    return text.encode(encoder, errors='ignore').decode().strip()
-#create excessive whitespace removal of text
-@text_cleansing_wrapper
-def remove_excessive_whitespace(text: str):
-    return re.sub("(\s)(\s+)", r"\1", text).strip()
-#create non-alphanumeric removal of text
-@text_cleansing_wrapper
-def remove_non_alphanumeric(text: str):
-    return re.sub("[^a-z0-9\s]", "", text, flags=re.I).strip()
-# def cleanse_wiki_text(text: str):
-#     return remove_html_tags(decode_url_and_remove_non_ascii(text))
-# def normalize_wiki_title(text: str):
-#     return remove_non_alphanumeric(remove_excessive_whitespace(text.lower()))
-def _text_normalizer_constructor(
-        remove_non_alphanumeric_bool: bool, remove_excessive_whitespace_bool: bool,
-        remove_html_tags_bool: bool, decode_url_bool: bool, encoder_check_bool: bool,
-        encoder: str="utf8"):
-    _lambda_fn_1 = partial(check_text_by_encoder, encoder=encoder) if encoder_check_bool else lambda x: x
-    _lambda_fn_2 = lambda x: remove_non_alphanumeric(_lambda_fn_1(x)) if remove_non_alphanumeric_bool else _lambda_fn_1(x)
-    _lambda_fn_3 = lambda x: remove_excessive_whitespace(_lambda_fn_2(x)) if remove_excessive_whitespace_bool else _lambda_fn_2(x)
-    _lambda_fn_4 = lambda x: remove_html_tags(_lambda_fn_3(x)) if remove_html_tags_bool else _lambda_fn_3(x)
-    _lambda_fn_5 = lambda x: decode_url(_lambda_fn_4(x)) if decode_url_bool else _lambda_fn_4(x)
-    return _lambda_fn_5
-def _args_to_text_constructor_fn(**kwargs):
-    def _decode_options(opt: str):
-        # return decoded options with format `text_opt`, `title_opt`
-        # possible values are ["all", "text", "title", "neither"]
-        if opt == "all":
-            return True, True
-        elif opt == "text":
-            return True, False
-        elif opt == "title":
-            return False, True
-        else:
-            return False, False
-    kwargs_title, kwargs_text = {}, {}
-    kwargs_title["encoder"] = kwargs["text_encoder_choice_title"]
-    kwargs_text["encoder"] = kwargs["text_encoder_choice_text"]
-    for key, val in kwargs.items():
-        if key not in [
-            "remove_non_alphanumeric_option", "remove_excessive_whitespace_option",
-            "remove_html_tags_option", "decode_url_option", "encoder_check_option"]:
-            continue
-        new_key = "_".join(key.split("_")[:-1]) + "_bool"
-        text_opt_val, title_opt_val = _decode_options(val)
-        kwargs_text[new_key], kwargs_title[new_key] = text_opt_val, title_opt_val
-    return _text_normalizer_constructor(**kwargs_text), _text_normalizer_constructor(**kwargs_title)
-def _text_processing_wrapper(text: str, _fn, mode: str="text"):
-    if mode not in ["text", "title"]:
-        raise ValueError(f"Provided `mode` isn't either 'text' or 'title'! Received: {mode}")
-    return _fn(text.lower()) if mode=="title" else _fn(text)
-### MAIN CODE ###
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--raw-csv-path", help="Relative location of csv file containing raw Wikipedia data")
-    parser.add_argument("--drop-hard-dupl", help="""Flag whether to drop hard duplicates
-                        (exact values of data of relevant text fields, Titles & Desc)""",
-          default=True, type=argparse_bool_check)
-    parser.add_argument("--drop-soft-dupl", help="""Flag whether to drop soft duplicates
-                        (duplicates after cleansed and normalized relevant text fields, Titles & Desc)""",
-          default=True, type=argparse_bool_check)
-    parser.add_argument("--save-dir-path", help="""Relative dir path of saved Wikipedia CSV data
-                        to the `dedup_raw_wiki_data.py` script dir""",
-            default=os.path.dirname(os.path.abspath(__file__)))
-    ### THE FOLLOWING ARGUMENTS ONLY TEMPORARILY ALTER THE TEXT DATA ONLY FOR SOFT-DEDUP CHECK ###
-    ### THE INITIAL TEXT DATA WON'T BE OVERWRITTEN AFTER BEING PREPROCESSED ###
-    ### UNLESS YOU ARE SPECIFYING IN ARGS `overwrite-initial-title-data` AND `overwrite-initial-text-data` ###
-    ### ARGS TO OVERWRITTE INITIAL TEXT DATA WITH PROCESSED ONES ###
-    parser.add_argument("--overwrite-initial-title-data", help="""Flag whether to overwrite title
-                        init data w/ processed data (True) or keep it as it is (False)""",
-          default=False, type=argparse_bool_check)
-    parser.add_argument("--overwrite-initial-text-data", help="""Flag whether to overwrite text
-                        init data w/ processed data (True) or keep it as it is (False)""",
-          default=False, type=argparse_bool_check)
-    ### INSTANTIATOR ARGS FOR CONSTRUCTING TEXT PROCESSING FN TO BE APPLIED ###
-    parser.add_argument("--remove-non-alphanumeric-option", help="""Identifier which columns to be preprocessed
-                        using `remove_non_alphanumeric` for soft duplicates detection
-                        (Choices are "all", "text", "title", "neither")""",
-          default="neither", type=text_processing_args_checker)
-    parser.add_argument("--remove-excessive-whitespace-option", help="""Identifier which columns to be preprocessed
-                        using `remove_excessive_whitespace` for soft duplicates detection
-                        (Choices are "all", "text", "title", "neither")""",
-          default="all", type=text_processing_args_checker)
-    parser.add_argument("--remove-html-tags-option", help="""Identifier which columns to be preprocessed
-                        using `remove_html_tags` for soft duplicates detection
-                        (Choices are "all", "text", "title", "neither")""",
-          default="all", type=text_processing_args_checker)
-    parser.add_argument("--decode-url-option", help="""Identifier which columns to be preprocessed
-                        using `decode_url` for soft duplicates detection
-                        (Choices are "all", "text", "title", "neither")""",
-          default="all", type=text_processing_args_checker)
-    ### ARGS TO CHOOSE ENCODER CHECKING AND ITS CONFIG INITIALIZATION ###
-    parser.add_argument("--encoder-check-option", help="""Identifier which columns to be preprocessed
-                        using `check_text_by_encoder` for soft duplicates detection
-                        (Choices are "all", "text", "title", "neither")""",
-          default="all", type=text_processing_args_checker)
-    parser.add_argument("--text-encoder-choice-title", help="""Identifier of title encoder type
-                        to be applied into `check_text_by_encoder` for soft duplicates detection""",
-          default="utf8", type=str)
-    parser.add_argument("--text-encoder-choice-text", help="""Identifier of text encoder type
-                        to be applied into `check_text_by_encoder` for soft duplicates detection""",
-          default="utf8", type=str)
-    _EXPECTED_COLNAMES = ["id", "url", "title", "text"]
-    logger = set_logger()
-    logger.info("Parsing arguments...")
-    args = parser.parse_args()
-    # class dotdict(dict):
-    #     """dot.notation access to dictionary attributes"""
-    #     __getattr__ = dict.get
-    #     __setattr__ = dict.__setitem__
-    #     __delattr__ = dict.__delitem__
-    # args = dotdict({
-    #     "raw_csv_path":"",
-    #     "drop_hard_dupl": True,
-    #     "drop_soft_dupl": True,
-    #     "save_dir_path": os.path.dirname(os.path.abspath(__file__)),
-    #     "overwrite_initial_title_data": False,
-    #     "overwrite_initial_text_data": False,
-    #     "remove_non_alphanumeric_option":"neither",
-    #     "remove_excessive_whitespace_option": "neither",
-    #     "remove_html_tags_option":"neither",
-    #     "decode_url_option":"neither",
-    #     "encoder_check_option":"all",
-    #     "text_encoder_choice_title":"utf8",
-    #     "text_encoder_choice_text":"utf8"
-    # })
-    _TEXT_PROCESSING_FN, _TITLE_PROCESSING_FN = _args_to_text_constructor_fn(
-        remove_non_alphanumeric_option = args.remove_non_alphanumeric_option,
-        remove_excessive_whitespace_option = args.remove_excessive_whitespace_option,
-        remove_html_tags_option = args.remove_html_tags_option,
-        decode_url_option = args.text_encoder_choice_title,
-        encoder_check_option = args.encoder_check_option,
-        text_encoder_choice_title = args.text_encoder_choice_title,
-        text_encoder_choice_text = args.text_encoder_choice_text
-    )
-    raw_data_path = args.raw_csv_path
-    drop_hard_dupl = args.drop_hard_dupl
-    drop_soft_dupl = args.drop_soft_dupl
-    save_dir = args.save_dir_path
-    overwrite_initial_title_data = args.overwrite_initial_title_data
-    overwrite_initial_text_data = args.overwrite_initial_text_data
-    df = pd.read_csv(raw_data_path)
-    if len(set(df.columns).difference(set(_EXPECTED_COLNAMES))) != 0 or len(set(_EXPECTED_COLNAMES).difference(set(df.columns))) != 0:
-        raise ValueError(f"The data schema expected, consist of columns: {', '.join(df.columns.to_list())} doesn't match with expected column values of {', '.join(_EXPECTED_COLNAMES)}!")
-    if (not drop_hard_dupl) and (not drop_soft_dupl):
-        raise AssertionError("The script won't run with both `drop-hard-dupl` and `drop-soft-dupl` args turned off!")
-    elif (not drop_hard_dupl):
-        warnings.warn("The args of `drop_hard_dupl` isn't turned off! Possibly the data will contain one template value of Wikipedia (usually no contribution text!)")
-    #will save id identifier colname first (popping first list val)
-    id_colname = _EXPECTED_COLNAMES.pop(0)
-    # if any of the data has duplicate values from columns checked (url, title, or text),
-    # it means the data integrity is questionable
-    # i.e. copied from other article or filled with template text
-    # hence, we will delete those duplicated datasets
-    #hard duplicate drop (drop all duplicate values that has exact same text on expected unique colnames)
-    if drop_hard_dupl:
-        for colname in _EXPECTED_COLNAMES:
-            logger.info(f"Checking data integrity on column {colname} on removing hard-duplicate(s)...")
-            dupl_text_df = df[df.duplicated(subset=colname,keep=False)]
-            shape_of_dupl_data = dupl_text_df.shape[0]
-            if shape_of_dupl_data > 0:
-                logger.info(f"Found {shape_of_dupl_data} data duplicated! Will be dropped")
-                df.drop_duplicates(subset=colname, keep=False, inplace=True)
-        #check id/idx of the cleansed data, whether it has duplicate
-        # (the duplication of id/idx should came from the very first extraction, not from the cleansing)
-        if df[df.duplicated(subset=id_colname,keep=False)].shape[0] > 0:
-            logger.info("Duplicated ID found! Re-assigning ID to the new ones based on `df.reset_index` method!")
-            df[id_colname] = df.reset_index().index
-    #soft duplicate drop (drop all except one duplicate values that has exact same text on expected unique colnames)
-    #keep the data that has longest value of its raw form
-    if drop_soft_dupl:
-        idx_to_keep = set(df.index.to_list())
-        #clean from text & title only, url isn't needed for this process
-        _EXPECTED_COLNAMES.remove("url")
-        for colname in _EXPECTED_COLNAMES:
-            #Construct Text Cleanser Fn for soft-duplicate cleansing
-            _PROCESSING_FN = _TEXT_PROCESSING_FN if colname == "text" else _TITLE_PROCESSING_FN
-            text_processing_fn = partial(_text_processing_wrapper, _fn=_PROCESSING_FN, mode=colname)
-            logger.info(f"Checking data integrity on column {colname} on removing soft-duplicate(s)...")
-            _df = df.copy(deep=True)
-            #Setting up DF cols as String so it can be text-processed
-            _df = _df[[colname]]
-            _df[colname] = _df[colname].astype("str")
-            logger.info(f"Cleansing the data based on {colname}")
-            #applying text processing
-            _df[colname+"_raw_len"] = _df[colname].apply(len)
-            _df[colname+"_cleansed"] = _df[colname].apply(lambda row_text: text_processing_fn(text=row_text))
-            #overwrite its text data if set as true
-            if overwrite_initial_title_data and colname == "title":
-                df[colname] = _df[colname+"_cleansed"]
-            elif overwrite_initial_text_data and colname == "text":
-                df[colname] = _df[colname+"_cleansed"]
-            #choose the data to keep by "ranking" it according to len of its raw text (greatest to keep)
-            logger.info(f"Ranking and grouping the data based on {colname}")
-            _df["rk"] = _df.groupby(colname+"_cleansed")[colname+"_raw_len"].rank(method="min", ascending=False)
-            shape_of_dupl_data = _df[_df["rk"]>1].shape[0]
-            if shape_of_dupl_data > 0:
-                logger.info(f"Found {shape_of_dupl_data} data duplicated! Will be dropped")
-                _idx_to_keep = _df[_df["rk"]==1].index.to_list()
-                if len(_idx_to_keep)+shape_of_dupl_data != df.shape[0]:
-                    raise AssertionError("Mismatch of data number!")
-                idx_to_keep = idx_to_keep.intersection(set(_idx_to_keep))
-            else:
-                logger.info(f"No soft-duplicate found in colname {colname}. Continuing")
-            del _df
-            gc.collect()
-        logger.info(f"The final data kept is {len(idx_to_keep)} from {df.shape[0]}")
-        df = df.loc[list(idx_to_keep),:]
-    logger.info("Saving dataset cleansed form...")
-    #input path splitted by ("/") for the last entry should return filename
-    #whereas the filename splitted by (".") except the last value should return the filename w/o ".csv" extension
-    _override_suffix_identifier = ""
-    if overwrite_initial_title_data or overwrite_initial_text_data:
-        _override_suffix_identifier = "_overwritten"
-        if overwrite_initial_text_data:
-            _override_suffix_identifier = "_text"+_override_suffix_identifier
-        if overwrite_initial_title_data:
-            _override_suffix_identifier = "_title"+_override_suffix_identifier
-    _save_file_name = ".".join(raw_data_path.split("/")[-1].split(".")[:-1]) + "_dedup_cleansed" + _override_suffix_identifier + ".csv"
-    _save_file_name = _save_file_name.replace("_raw", "")
-    df.to_csv(f"{save_dir}/{_save_file_name}", index=False)

dedup_raw_wiki_data_sea.sh DELETED Viewed

@@ -1,62 +0,0 @@
-#!/bin/bash
-# all available lang codes in SEA local-languages or linguistically-related to following countries in SEA:
-# Indonesia: "ace" (Acehnese), "ban" (Balinese), "bjn" (Banjarese), "bug" (Buginese), "gor" (Gorontalo), "id" (Indonesian), "jv" (Javanese), "mad" (Madurese), "map-bms" (Banyumasan, Dialect of Javanese), "min" (Minangkabau), "ms" (Malay), "nia" (Nias), "su" (Sundanese), "tet" (Tetum)
-# Singapore: "ms" (Malay), "ta" (Tamil)
-# Malaysia: "ms" (Malay), "ta" (Tamil)
-# Brunei: "ms" (Malay)
-# Thailand: "mnw" (Mon), "shn" (Shan), "th" (Thai)
-# Myanmar: "my" (Burmese), "mnw" (Mon), "shn" (Shan)
-# Laos: "lo" (Lao)
-# Vietnam: "vi" (Vietnamese)
-# Cambodia: "km" (Khmer)
-# East Timor: "tet" (Tetum)
-# Philippines: "bcl" (Central Bicolano), "cbk-zam" (Chavacano), "ceb" (Cebuano), "ilo" (Ilokano), "pag" (Pangasinan), "pam" (Kapampangan), "tl" (Tagalog), "war" (Waray)
-#params of executions
-folder_dir_to_save=./sea_wiki_dedup_data
-input_folder_to_be_dedup=./sea_wiki_raw_data
-drop_hard_dupl=True
-drop_soft_dupl=True
-# main executions
-# src: https://stackoverflow.com/a/18887210 (to list all files under a dir)
-shopt -s nullglob
-file_name_array=($input_folder_to_be_dedup/*)
-shopt -u nullglob # Turn off nullglob to make sure it doesn't interfere with anything later
-file_name_array="${file_name_array}"
-if [ ${#file_name_array[@]} == 0 ]; then
-    echo "No files found under directory $input_folder_to_be_dedup" >&2
-fi
-if [ ! -d $folder_dir_to_save ];
-then
-    echo "Dir $folder_dir_to_save not exists! Creating the dir..."
-    mkdir $folder_dir_to_save
-fi
-echo "The params hard-dedup drop is set as $drop_hard_dupl"
-echo "The params soft-dedup drop is set as $drop_soft_dupl"
-for val in ${!file_name_array[@]}; do
-    csv_path=${file_name_array[$val]}
-    if [[ ${csv_path} != *".csv" ]]; then
-        echo "The extracted file name isn't a CSV! Skipping! Received $csv_path"
-        continue
-    fi
-    echo "Executing Dedup on iteration no "$((val+1))" of total ${#file_name_array[@]} for input data $csv_path"
-    #see the script bcs there are more args than this command is using
-    python dedup_raw_wiki_data.py \
-        --raw-csv-path $csv_path \
-        --drop-hard-dupl $drop_hard_dupl \
-        --drop-soft-dupl $drop_soft_dupl \
-        --save-dir-path $folder_dir_to_save
-    echo "Done Execution"
-done
-echo "Done Dedup Process"

extract_raw_wiki_data.py DELETED Viewed

@@ -1,73 +0,0 @@
-'''
-Script on Generating Wikipedia Data that are dumped into https://dumps.wikimedia.org/
-More info can be read on https://huggingface.co/datasets/wikipedia
--------------------
-Check here to see available indexed data: https://dumps.wikimedia.org/backup-index.html
-Also check here to see language meta from its code: https://meta.wikimedia.org/wiki/List_of_Wikipedias
-'''
-import os, gc
-import logging
-import argparse
-import pandas as pd
-from datasets import load_dataset
-def set_logger():
-    # Set up the logger
-    logging.basicConfig(
-        level=logging.INFO,  # Set the desired logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
-        format='%(asctime)s [%(levelname)s]: %(message)s',  # Customize the log message format
-        datefmt='%Y-%m-%d %H:%M:%S'  # Customize the date/time format
-    )
-    # Create a file handler to write logs into a file
-    file_handler = logging.FileHandler('app.log')
-    # Set the log level for the file handler
-    file_handler.setLevel(logging.INFO)
-    # Create a formatter for the file handler (customize the log format for the file)
-    file_formatter = logging.Formatter('%(asctime)s [%(levelname)s]: %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
-    file_handler.setFormatter(file_formatter)
-    logger = logging.getLogger("Wiki Dataset Generation")
-    logger.addHandler(file_handler)
-    return logger
-#only executed if called directly
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--lang-id", help="Lang ID from Wikipedia Data to extract")
-    parser.add_argument("--date-ver", help="Date of Wikipedia Data (YYYYMMDD) generation to extract")
-    parser.add_argument("--save-dir-path", help="""Relative dir path of saved Wikipedia CSV data
-                        to the `extract_raw_wiki_data.py` script dir""",
-            default=os.path.dirname(os.path.abspath(__file__)))
-    args = parser.parse_args()
-    dset_name = "wikipedia"
-    logger = set_logger()
-    logger.info("Parsing arguments...")
-    lang_id = args.lang_id
-    date_ver = args.date_ver
-    save_dir = args.save_dir_path
-    logger.info("Loading the dataset from Wikipedia...")
-    df = load_dataset(dset_name, language=lang_id, date=date_ver, beam_runner='DirectRunner', split="train").to_pandas()
-    logger.info("Loading done!")
-    logger.info(f"#Data collected: {df.shape[0]}")
-    logger.info("Saving dataset raw form...")
-    df.to_csv(f"{save_dir}/wiki_{lang_id}_{date_ver}_raw_dataset.csv", index=False)
-    del df
-    gc.collect()

extract_raw_wiki_data_batched.py DELETED Viewed

@@ -1,87 +0,0 @@
-'''
-Script on Generating Wikipedia Data that are dumped into https://dumps.wikimedia.org/
-More info can be read on https://huggingface.co/datasets/wikipedia
--------------------
-Check here to see available indexed data: https://dumps.wikimedia.org/backup-index.html
-Also check here to see language meta from its code: https://meta.wikimedia.org/wiki/List_of_Wikipedias
-'''
-import os, gc
-import logging
-import argparse
-import pandas as pd
-from datasets import load_dataset
-def set_logger():
-    # Set up the logger
-    logging.basicConfig(
-        level=logging.INFO,  # Set the desired logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
-        format='%(asctime)s [%(levelname)s]: %(message)s',  # Customize the log message format
-        datefmt='%Y-%m-%d %H:%M:%S'  # Customize the date/time format
-    )
-    # Create a file handler to write logs into a file
-    file_handler = logging.FileHandler('app.log')
-    # Set the log level for the file handler
-    file_handler.setLevel(logging.INFO)
-    # Create a formatter for the file handler (customize the log format for the file)
-    file_formatter = logging.Formatter('%(asctime)s [%(levelname)s]: %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
-    file_handler.setFormatter(file_formatter)
-    logger = logging.getLogger("Wiki Dataset Generation")
-    logger.addHandler(file_handler)
-    return logger
-#only executed if called directly
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--lang-id", help="Lang ID from Wikipedia Data to extract")
-    parser.add_argument("--date-ver", help="Date of Wikipedia Data (YYYYMMDD) generation to extract")
-    #default: all
-    parser.add_argument("--split-extr", help="""Split extraction config for choosing
-                        subsets of data to process. It follows python list slicing string args""",
-            default=":")
-    #default: all
-    parser.add_argument("--force_rerun_split", help="""Flag to identify whether to check existing
-                        splits or forcing to re-create it""",
-            default=False)
-    parser.add_argument("--save-dir-path", help="""Relative dir path of saved Wikipedia CSV data
-                        to the `extract_raw_wiki_data.py` script dir""",
-            default=os.path.dirname(os.path.abspath(__file__)))
-    args = parser.parse_args()
-    dset_name = "sea_loader_batched/wiki_loader.py"
-    logger = set_logger()
-    logger.info("Parsing arguments...")
-    lang_id = args.lang_id
-    date_ver = args.date_ver
-    generated_split_extraction = args.split_extr
-    force_rerun_split_generation = args.force_rerun_split
-    save_dir = args.save_dir_path
-    logger.info("Loading the dataset from Wikipedia...")
-    df = load_dataset(dset_name, language=lang_id, date=date_ver, beam_runner='DirectRunner',
-                        split="train", subset_file_to_process=generated_split_extraction,
-                        force_rerun_split=force_rerun_split_generation).to_pandas()
-    logger.info("Loading done!")
-    logger.info(f"#Data collected: {df.shape[0]}")
-    logger.info("Saving dataset raw form...")
-    df.to_csv(f"{save_dir}/wiki_{lang_id}_{date_ver}_raw_dataset_splitted.csv", index=False)
-    del df
-    gc.collect()

extract_raw_wiki_data_sea.sh DELETED Viewed

@@ -1,38 +0,0 @@
-#!/bin/bash
-# all available lang codes in SEA local-languages or linguistically-related to following countries in SEA:
-# Indonesia: "ace" (Acehnese), "ban" (Balinese), "bjn" (Banjarese), "bug" (Buginese), "gor" (Gorontalo), "id" (Indonesian), "jv" (Javanese), "mad" (Madurese), "map-bms" (Banyumasan, Dialect of Javanese), "min" (Minangkabau), "ms" (Malay), "nia" (Nias), "su" (Sundanese), "tet" (Tetum)
-# Singapore: "ms" (Malay), "ta" (Tamil)
-# Malaysia: "ms" (Malay), "ta" (Tamil)
-# Brunei: "ms" (Malay)
-# Thailand: "mnw" (Mon), "shn" (Shan), "th" (Thai)
-# Myanmar: "my" (Burmese), "mnw" (Mon), "shn" (Shan)
-# Laos: "lo" (Lao)
-# Vietnam: "vi" (Vietnamese)
-# Cambodia: "km" (Khmer)
-# East Timor: "tet" (Tetum)
-# Philippines: "bcl" (Central Bicolano), "cbk-zam" (Chavacano), "ceb" (Cebuano), "ilo" (Ilokano), "pag" (Pangasinan), "pam" (Kapampangan), "tl" (Tagalog), "war" (Waray)
-#params of executions
-date_ver=20231101
-folder_dir_to_save=./sea_wiki_raw_data
-lang_list=(ace ban bcl bjn bug cbk-zam ceb gor id ilo jv km lo mad map-bms min mnw ms my nia pag pam shn su tet ta th tl vi war)
-#main executions
-if [ ! -d $folder_dir_to_save ]; then
-    echo "Dir $folder_dir_to_save not exists! Creating the dir..."
-    mkdir $folder_dir_to_save
-fi
-for val in ${!lang_list[@]}; do
-    lang=${lang_list[$val]}
-    echo "Executing Extractor on iteration no $((val+1)) of total ${#lang_list[@]} for language $lang and date version of $date_ver"
-    python extract_raw_wiki_data.py \
-        --lang-id $lang \
-        --date-ver $date_ver \
-        --save-dir-path $folder_dir_to_save
-    echo "Done Execution"
-done
-echo "Done Extraction Process"