Update README.md

README.md

@@ -453,9 +453,9 @@ configs:
     path: data/Python/train-*
 ---
 
-# Dataset Summary
+# The Heap Dataset
 
-We develop a new contamination-free multilingual code dataset that facilitates LLM evaluation reproducibility. 
+We develop **The Heap**, a new contamination-free multilingual code dataset comprising 50 languages, that facilitates LLM evaluation reproducibility.
 
 # Collection
 
@@ -468,7 +468,6 @@ We collect up to **50,000** public repositories using the [GitHub API](https://d
 | GPL-2.0, GPL-3.0 | Strong Copyleft   |
 | AGPL-3.0, EUPL-1.1, EUPL-1.2, OSL-3.0 | Network Copyleft   |
 
-Table 1: Copyleft licenses included in the dataset
 
 The features we extract for each repository are illustrated in the example below.
 
@@ -513,7 +512,54 @@ The features we extract for each repository are illustrated in the example below
 
 We start by retrieving repositories with more than **900** stars using **two-month tumbling windows**. If we hit the **1000** repository limit per window (for a personal GitHub account), we shorten the
 search space to a **one-month window** and restart the iteration. Otherwise, the window advances by two months. Once the entire timeframe (until **April 2024**) is covered, we reduce the star search space: between **900** and **100** stars, we decrease the interval by **50** (e.g. search between [900, 850]), between **100** and **10** stars, we decrease the interval by **10**, and for the last **10** stars, we decrease by **1**. Since most repositories fall within the **0-100 star range** (e.g. Figure 1 showcases the distribution of repositories with up to **500** stars for Java), using the **creation date** and **star count** filters helps us avoid API limits and scrape more data by narrowing the search space. 
-The creation date window can be reduced even further (week or day level), in order to extract more data. After retrieving the repositories, we extract all the files corresponding to each language. We extend the programming languages extension list used for [The Stack](https://gist.github.com/ppisarczyk/43962d06686722d26d176fad46879d41) with 4 languages: EJS, Raku, Starlark, and WebAssembly. 
+The creation date window can be reduced even further (week or day level), in order to extract more data. We remove any potential duplicated repositories obtained due to the pagination process. Lastly, we extract all the files corresponding to each language. We extend the programming languages extension list used for [The Stack](https://gist.github.com/ppisarczyk/43962d06686722d26d176fad46879d41) with 4 languages: EJS, Raku, Starlark, and WebAssembly. 
+
+
+<!-- ![image/png](https://cdn-uploads.huggingface.co/production/uploads/66a89f0fd6625ead0411af50/fctcChY0DRwxMeXazUWUV.png) -->
+<div style="text-align: center;">
+    <img src=https://cdn-uploads.huggingface.co/production/uploads/66a89f0fd6625ead0411af50/fctcChY0DRwxMeXazUWUV.png alt="Figure 1: Distribution of scraped repositories with at most 500 stars." style="display: block; margin: 0 auto; width: 600px; height: auto;" />
+    <p><b>Figure 1:</b> Distribution of scraped repositories with at most 500 stars for Java</p>
+</div>
+
+
+# Cleaning
+
+The next stage in our dataset pipeline is the cleaning procedure. We exclude any files **larger than 10 MB** and those with **fewer than 10 words**.
+
+# Deduplication
+
+The final stage of our dataset pipeline is the deduplication process. We apply both exact and near deduplication against open code datasets listed in the table below. 
+
+### Open code dataset used for deduplication
+| **Dataset**    | **Size** |
+| :--------: | :-------: |
+| The Stack V2  | 67.5 TB   |
+| The Stack   | 6.4 TB    |
+| Red Pajama |    2.67 TB    |
+| GitHub Code |    1 TB    |
+| CodeParrot | 180 GB |
+
+## Exact Deduplication
+We remove exact duplicates **within our dataset itself**, and then we apply exact deduplication against the open datasets. For that, we use the **sha256** function to generate hashes for each file.
+We choose this hash function because it provides a uniform distribution of hash values, minimizes collisions, and ensures even distribution across the hash space.
+
+## Near Deduplication
+
+We apply the **MinHashLSH** algorithm using the [*datasketch1*](https://ekzhu.com/datasketch/lsh.html) library. To calculate the minhashes, we use the same hash function as above, but we extract the first 16 bytes to generate 128-bit hash values. 
+This approach balances the need for a strong hash function with the efficiency of a shorter hash length. 
+
+Additionally, we use **128** file permutations for LSH, with weights of **0.4** for **precision** and **0.6** for **recall**. We generate **7-character shingles** after [lowercasing the file content and removing whitespace](http://infolab.stanford.edu/~ullman/mmds/book.pdf). 
+We find that 7-shingles provide a reasonable trade-off between the number of shingles and the data processed, being small enough to keep the number of unique shingles manageable yet large enough to provide meaningful comparisons. 
+It was shown that the number of shingles should be large enough to ensure a low probability of shingles appearing across documents, with **k = 5** suggested for smaller documents such as [emails](http://infolab.stanford.edu/~ullman/mmds/book.pdf). 
+However, code files usually contain a **larger dictionary** of characters than emails, including arithmetic and comparison operators which are less frequent in emails. 
+Thus, given the increased **complexity** and **size** of code files, we consider 7-shingles to be appropriate to capture sufficient context, ensuring uniqueness and **reducing false positives**, which smaller shingles such as k = 5 might fail to achieve. 
+Furthermore, **k = 9** was shown to be a safe choice for [large research articles](http://infolab.stanford.edu/~ullman/mmds/book.pdf), however, for our needs, 7-shingles strike a balance between accuracy and
+computational efficiency, crucial for handling the extensive size of the datasets. This choice provides better computational efficiency by reducing the number of comparisons while maintaining a manageable shingle space.
+Lastly, we use a **Jaccard similarity threshold** of **0.7**, which proved to be efficient for both [SantaCoder](https://arxiv.org/abs/2301.03988) and [StarCoder](https://arxiv.org/abs/2305.06161) models. A high threshold
+reduces false positives, leading to fewer unnecessary comparisons and lower computational overhead. Moreover, this standard threshold value has been shown to be [robust for duplicate detection](https://dl.acm.org/doi/10.1145/3359591.3359735). 
+
+
+Instead of removing exact and near duplicates found against other open datasets, we add a boolean mask to our dataset. This approach enhances reproducibility by allowing researchers to filter the dataset for unique files, according to their specific requirements.
 
 The final dataset structure is shown in the example below.
 
@@ -560,73 +606,24 @@ The final dataset structure is shown in the example below.
 - **exact_duplicates_pubdataset**: boolean flag stating if there are any exact duplicate files found against another public dataset (The Stackv2, The Stack, RedPajama, GithubCode, CodeParrot)
 - **near_duplicates_pubdataset**: boolean flag stating if there are any near duplicate files found against another public dataset (The Stackv2, The Stack, RedPajama, GithubCode, CodeParrot)
 
-<!-- ![image/png](https://cdn-uploads.huggingface.co/production/uploads/66a89f0fd6625ead0411af50/fctcChY0DRwxMeXazUWUV.png) -->
-<div style="text-align: center;">
-    <img src=https://cdn-uploads.huggingface.co/production/uploads/66a89f0fd6625ead0411af50/fctcChY0DRwxMeXazUWUV.png alt="Figure 1: Distribution of scraped repositories with at most 500 stars." style="display: block; margin: 0 auto; width: 600px; height: auto;" />
-    <p><b>Figure 1:</b> Distribution of scraped repositories with at most 500 stars for Java</p>
-</div>
-
-
-# Cleaning
-
-The next stage in our dataset pipeline is the cleaning procedure. We exclude any files **larger than 10 MB** and those with **fewer than 10 words**.
-
-# Deduplication
-
-The final stage of our dataset pipeline is the deduplication process. Firstly, we remove any potential duplicated repositories obtained due to the pagination process. We then perform **exact deduplication** between **our dataset and the Java-Stack v2**, and **within our dataset itself**, using the **sha256** function to generate hashes for each file.
-We choose this hash function because it provides a uniform distribution of hash values, minimizes collisions, and ensures even distribution across the hash space.
-For **near-deduplication**, we use the **MinHashLSH** algorithm from the [*datasketch1*](https://ekzhu.com/datasketch/lsh.html) library. To calculate the minhashes, we use the same hash function as above, but we extract the first 16 bytes to generate 128-bit hash values. 
-This approach balances the need for a strong hash function with the efficiency of a shorter hash length. 
-
-Additionally, we use **128** file permutations for LSH, with weights of **0.4** for **precision** and **0.6** for **recall**. We generate **7-character shingles** after [lowercasing the file content and removing whitespace](http://infolab.stanford.edu/~ullman/mmds/book.pdf). 
-We find that 7-shingles provide a reasonable trade-off between the number of shingles and the data processed, being small enough to keep the number of unique shingles manageable yet large enough to provide meaningful comparisons. 
-It was shown that the number of shingles should be large enough to ensure a low probability of shingles appearing across documents, with **k = 5** suggested for smaller documents such as [emails](http://infolab.stanford.edu/~ullman/mmds/book.pdf). 
-However, Java files usually contain a **larger dictionary** of characters than emails, including arithmetic and comparison operators which are less frequent in emails. 
-Thus, given the increased **complexity** and **size** of Java files, we consider 7-shingles to be appropriate to capture sufficient context, ensuring uniqueness and **reducing false positives**, which smaller shingles such as k = 5 might fail to achieve. 
-Furthermore, **k = 9** was shown to be a safe choice for [large research articles](http://infolab.stanford.edu/~ullman/mmds/book.pdf), however, for our needs, 7-shingles strike a balance between accuracy and
-computational efficiency, crucial for handling the **Java-Stack v2’s size** of over **222 M** files. This choice provides better computational efficiency by reducing the number of comparisons while maintaining a manageable shingle space.
-Lastly, we use a **Jaccard similarity threshold** of **0.7**, which proved to be efficient for both [SantaCoder](https://arxiv.org/abs/2301.03988) and [StarCoder](https://arxiv.org/abs/2305.06161) models. Such a high threshold
-reduces false positives, leading to fewer unnecessary comparisons and lower computational overhead. Moreover, this standard threshold value has been shown to be [robust for duplicate detection](https://dl.acm.org/doi/10.1145/3359591.3359735). 
-
-Instead of removing near-duplicates, we introduce a new feature to our dataset, called *near_dups_stkv2_idx*. This feature is a list of IDs of the near-duplicate files from the Java-Stack v2 corresponding to the current file in our dataset.
-The table below shows the number of files removed by each preprocessing method and the final number of files we are left with in the end (excluding near-duplicates). 
-Starting with **7.8 M** files, we are left with about **2.13 M** after applying all pre-processing methods (this includes near-duplicates). 
-Of the removed files, approximately **5.63 M** are exact duplicates (including about **0.87 M** from Java-Stack v2), and **0.8 M** are near-duplicates from Java-Stack v2. 
-This implies that training any LLM on Stack v2 will breach copy-left code licenses, despite the dataset creators’ claim that files under such licenses were removed.
-
-### Files removed by each pre-processing method
-| **Method**    | **#Files** |
-| :--------: | :-------: |
-| Raw dataset  | 7.80 M    |
-| Auto-generated |   0.04 M   |
-| Exact-deduplication    | 5.63 M    |
-| Near-deduplication |    0.80 M    |
-| Final dataset | 1.33 M |
-
 
 # Usage 
 
-By default, the dataset includes near-duplicate entries from Java-Stack v2, with their IDs listed in the *near_dups_stkv2_idx* field. 
-*An entry with an empty list in this field indicates that no near-duplicate files were found in Java-Stack v2 for that specific file.* 
-
-Near-duplicates can be removed as shown in the example below.
+Using the Datasets API, our dataset can be used as follows:
 
 ```python
 from datasets import load_dataset
 
-# Load dataset
-dataset = load_dataset("LaughingLogits/Stackless_Java_V2")
-
-# Load train split (only one split available)
-dataset = load_dataset("LaughingLogits/Stackless_Java_V2", split="train")
+dataset_name = 'redpajama'
+language = 'Python'
 
-# Dataset streaming
-data = load_dataset("LaughingLogits/Stackless_Java_V2", split="train", streaming= True)
-for sample in iter(data):
-    print(sample["content"])
+ds = load_dataset(
+    "WizzF/Heap-Forge",
+    f"{language}",
+    split="train",
+    num_proc=16
+)
 
-# Filter dataset to not include near-duplicates from Java-Stack v2
-dataset = load_dataset("LaughingLogits/Stackless_Java_V2", split="train")
-near_deduplicated_dataset = dataset.filter(lambda sample: len(sample["near_dups_stkv2_idx"]) == 0)
+ds = ds.filter(lambda x: not x[f'exact_duplicates_{dataset_name}'] and not x[f'near_duplicates_{dataset_name}'])
 
 ```