README.md

---
pretty_name: "LittleTzu FineWeb-Edu Tokenized (Custom 65k Balanced)"
language:
- en
- zh
- ja
- ko
- it
- es
- de
license: other
task_categories:
- text-generation
tags:
- pretraining
- tokenized
- fineweb-edu
- numpy
- custom-tokenizer
- bpe
size_categories:
- 10B<n<100B
---

# LittleTzu FineWeb-Edu Tokenized (Custom 65k Balanced)

Tokenized shards of **FineWeb-Edu** (`HuggingFaceFW/fineweb-edu`, config: `sample-10BT`) for language model pretraining. 

This dataset stores a derived, tokenized representation of the original FineWeb-Edu corpus. It has been tokenized using **LittleTzu's custom 65K balanced tokenizer**, optimized for multi-domain training (English, multilingual text, math, and code) while maintaining a compact vocabulary footprint that fits within a `uint16` data type.

## Dataset Structure

The dataset consists of flat 1D NumPy binary shards (`.npy` files) serialized in `uint16` format:
- `edufineweb_val_000000.npy` (Validation set: first shard, containing exactly 100M tokens)
- `edufineweb_train_000001.npy`
- `edufineweb_train_000002.npy`
- ...
- `edufineweb_train_000099.npy`

Each shard contains exactly **100,000,000** (100M) tokens. Shards are created by tokenizing raw documents from the source, prefixing/delimiting each document with the `<|eos|>` token, and packing them into contiguous 100M token arrays.

## Custom Tokenizer: `tokenizer_65k_balanced`

To overcome the vocabulary size overhead of tokenizers like OpenAI's `cl100k_base` (100k vocab) or Llama 3 (128k vocab) when training smaller models (~124M to 500M parameters), we trained a custom **Byte-Level BPE tokenizer** with a vocabulary size of **65,536**.

### Tokenizer Configuration
- **Model Type**: Byte-Level BPE (Byte Pair Encoding)
- **Vocabulary Size**: 65,536 (fits natively in `uint16` arrays, saving 50% memory/storage overhead during loading compared to standard `uint32` or `int32`/`int64` loaders!)
- **Pre-tokenization**: 
  - `ByteLevel(add_prefix_space=False)`
  - `Digits(individual_digits=True)` — Splits digits individually (e.g. `123` becomes `1`, `2`, `3`) to prevent the vocabulary from being bloated with random numbers and to ensure stable mathematical tokenization.
- **Special & Control Tokens**:
  - Standard: `<|pad|>`, `<|bos|>`, `<|eos|>`, `<|unk|>`, `<|sep|>`
  - Chat Format: `<|im_start|>`, `<|im_end|>`
  - Reserved: 50 reserved placeholders (`<|reserved_0|>` to `<|reserved_49|>`) for future-proofing and custom special tokens.

### Training Mixture (Balanced Corpus)
To ensure the tokenizer remains highly efficient across various domains despite its compact vocabulary, it was trained on a balanced 5,000,000 document subset spanning the following domains:
1. **English (General & Educational)**: `HuggingFaceFW/fineweb-edu` (25%)
2. **Multilingual Chinese**: `epfml/FineWeb2-HQ` (`cmn_Hani` config) (20%)
3. **Multilingual Italian**: `HuggingFaceFW/fineweb-2` (`ita_Latn` config) (15%)
4. **Math / Scientific**: `open-web-math/open-web-math` (15%)
5. **Multilingual Japanese**: `epfml/FineWeb2-HQ` (`jpn_Jpan` config) (10%)
6. **Code (Programming)**: `bigcode/the-stack-v2-train-smol` (10%)
7. **Multilingual Korean**: `HuggingFaceFW/fineweb-2` (`kor_Hang` config) (5%)

### Tokenization Compression Efficiency (Chars/Token)
The balanced training corpus ensures the custom tokenizer compresses multilingual text and code far more efficiently than general-purpose English tokenizers, even with 35% fewer vocabulary dimensions:

| Language / Domain | Custom 65k (chars/token) | OpenAI cl100k_base (chars/token) | Relative Efficiency |
|---|---|---|---|
| **English** | 5.13 | 5.13 | **Parity** (1.00x) |
| **Italian** | 5.19 | 3.59 | **+44.5%** (1.44x) |
| **Korean** | 1.71 | 1.09 | **+56.8%** (1.57x) |
| **Japanese** | 1.38 | 0.85 | **+62.3%** (1.62x) |
| **Chinese** | 1.20 | 0.94 | **+27.6%** (1.28x) |
| **Python Code** | 2.35 | 2.94 | -20.0% (0.80x) |

*By optimizing for multi-domain text, each sequence packed into the model context carries denser semantic information, speeding up pre-training convergence on multilingual benchmarks.*

## Data Preparation & Preprocessing

This dataset was tokenized and sharded via a parallelized processing script (`fineweb.py`) which:
1. Streams documents from the original `HuggingFaceFW/fineweb-edu` (`sample-10BT`) dataset.
2. Tokenizes document text using the `tokenizer_65k_balanced.json` model.
3. Prepends the `<|eos|>` token to every document.
4. Packs token streams into contiguous `1D` NumPy array buffers of size `100,000,000`.
5. Casts and saves each shard as `np.uint16` to a local directory or uploads to Hugging Face.

## How to Load and Stream

You can download and stream these tokenized shards using the Hugging Face Hub snapshot API or load them directly into your dataset loaders.

### 1. Download Shards
```python
from huggingface_hub import snapshot_download

snapshot_download(
    repo_id="Neetree/fineweb10B-tokenized-custom",
    repo_type="dataset",
    local_dir="data/edu_fineweb10B",
    allow_patterns="*.npy",
)
```

### 2. PyTorch DataLoader Example
Here is how you can implement an efficient, lightweight streaming dataloader using `np.load`:

```python
import os
import numpy as np
import torch

class ShardDataLoader:
    def __init__(self, data_dir, batch_size, seq_len, split="train"):
        self.B = batch_size
        self.T = seq_len
        self.shards = sorted([os.path.join(data_dir, f) for f in os.listdir(data_dir) if split in f])
        assert len(self.shards) > 0, f"No shards found for split: {split}"
        
        self.current_shard_idx = 0
        self._load_shard()
        
    def _load_shard(self):
        shard_path = self.shards[self.current_shard_idx]
        # Memory-map the file to prevent loading the entire 100M array into RAM at once
        self.tokens = np.load(shard_path, mmap_mode="r")
        self.current_pos = 0
        
    def next_batch(self):
        B, T = self.B, self.T
        # We need B * T + 1 tokens to construct input (X) and target (Y)
        needed = B * T + 1
        
        if self.current_pos + needed > len(self.tokens):
            # Advance to the next shard
            self.current_shard_idx = (self.current_shard_idx + 1) % len(self.shards)
            self._load_shard()
            
        buf = self.tokens[self.current_pos : self.current_pos + needed]
        self.current_pos += B * T
        
        # Convert uint16 array to torch.long for embedding layer lookup
        tensor = torch.from_numpy(buf.astype(np.int64))
        x = tensor[:-1].view(B, T)
        y = tensor[1:].view(B, T)
        
        return x, y
```

## Intended Use

- Large-scale causal language model pretraining.
- Benchmarking dataloading pipelines.
- Lightweight and budget-friendly model training baseline (compatible with LittleTzu training configs).

## Citation & Original Dataset

Original dataset is FineWeb-Edu by Hugging Face:
```bibtex
@misc{lozhkov2024fineweb-edu,
    author       = { Lozhkov, Anton and Ben Allal, Loubna and von Werra, Leandro and Wolf, Thomas },  
    title        = { FineWeb-Edu: the Finest Collection of Educational Content }, 
    year         = 2024,  
    url          = { https://huggingface.co/datasets/HuggingFaceFW/fineweb-edu },  
    doi          = { 10.57967/hf/2497 },
    publisher    = { Hugging Face }
}
```
If you use this sharded/tokenized representation, please cite the original creators of the FineWeb-Edu dataset.