github_preprocessing.py

import gzip
import multiprocessing
import os
import shutil
import time
from argparse import Namespace
from collections import Counter
import numpy as np
from datasets import load_dataset, utils
import re
from huggingface_hub import Repository
from multiprocessing import Pool
from tqdm import tqdm

# Settings
config = {
    "dataset_name": "./data/github",
    "num_workers": 96,
    "line_max": 1000,
    "out_path": "./data/github-code",
    "repo_name": "github-code",
    "org": "lvwerra",
    "shard_size": 1000 << 20}

args = Namespace(**config)

PATTERN = re.compile(r'\s+')


def hash_func(text):
    return hashlib.md5(re.sub(PATTERN, '', text).encode("utf-8")).hexdigest()

def get_hash(example):
    """Get hash of content field."""
    return {"hash": hash_func(example["content"])}


def line_stats(example):
    """Calculates mean and max line length of file."""
    line_lengths = [len(line) for line in example["content"].splitlines()]
    return {"line_mean": np.mean(line_lengths), "line_max": max(line_lengths)}


def alpha_stats(example):
    """Calculates mean and max line length of file."""
    alpha_frac = np.mean([c.isalnum() for c in example["content"]])
    return {"alpha_frac": alpha_frac}


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 is_autogenerated(example, scan_width=5):
    """Check if file is autogenerated by looking for keywords in the first few lines of the file."""
    keywords = ["auto-generated", "autogenerated", "automatically generated"]
    lines = example["content"].splitlines()
    for _, line in zip(range(scan_width), lines):
        for keyword in keywords:
            if keyword in line.lower():
                return {"autogenerated": True}
    else:
        return {"autogenerated": False}


def preprocess(example):
    """Chain all preprocessing steps into one function to not fill cache."""
    results = dict()
    results.update(get_hash(example))
    results.update(line_stats(example))
    return results


def filter(example, uniques, args):
    """Filter dataset with heuristics."""
    if not check_uniques(example, uniques):
        return False
    elif example["line_max"] > args.line_max:
        return False
    else:
        return True
    
def save_shard(shard_tuple):
    """Save shard"""
    filename, shard = shard_tuple
    shard.to_parquet(filename)

# Load dataset
t_start = time.time()
ds = load_dataset(args.dataset_name, split="train", chunksize=40<<20)
print(f"Time to load dataset: {time.time()-t_start:.2f}")

# Run preprocessing
t_start = time.time()
ds = ds.map(preprocess, num_proc=args.num_workers)
print(f"Time to preprocess dataset: {time.time()-t_start:.2f}")
print(ds)

# Deduplicate hashes
uniques = set(ds.unique("hash"))
frac = len(uniques) / len(ds)
print(f"Fraction of duplicates: {1-frac:.2%}")

# Deduplicate data and apply heuristics
t_start = time.time()
ds = ds.filter(filter, fn_kwargs={"uniques": uniques, "args": args})
ds = ds.remove_columns(["line_mean", "line_max", "copies", "hash"])
print(f"Time to filter dataset: {time.time()-t_start:.2f}")
print(f"Size of filtered dataset: {len(ds)}")


# Save dataset in repo
repo = Repository(
        local_dir=args.out_path,
        clone_from=args.org + "/" + args.repo_name,
        repo_type="dataset",
        private=True,
        use_auth_token=True,
        git_user="lvwerra",
        git_email="leandro.vonwerra@gmail.com",
        )

os.mkdir(args.out_path + "/data")

if ds._indices is not None:
    dataset_nbytes = ds.data.nbytes * len(ds._indices) / len(ds.data)
else:
    dataset_nbytes = ds.data.nbytes

num_shards = int(dataset_nbytes / args.shard_size) + 1
print(f"Number of shards: {num_shards}")

t_start = time.time()
shards = (ds.shard(num_shards=num_shards, index=i, contiguous=True) for i in range(num_shards))
filenames = (f"{args.out_path}/data/train-{index:05d}-of-{num_shards:05d}.parquet" for index in range(num_shards))

with Pool(16) as p:
    list(tqdm(p.imap_unordered(save_shard, zip(filenames, shards), chunksize=4), total=num_shards))
print(f"Time to save dataset: {time.time()-t_start:.2f}")

# To push to hub run `git add/commit/push` inside dataset repo folder