haradi/chatlm-pretrain-10b

ChatLM pretraining corpus, part 1 (partial, 26 shards)

This repository holds the first 26 shards of a planned 10B-token pretraining corpus for a ~500M-parameter GPT-style model. The run stopped while uploading shard 26, after a Hugging Face rate limit (HTTP 429). The rest of the corpus is in a new repository: [NEW_REPO_NAME].

Status: partial. About 2.6B of the planned 10B training tokens are here.

Contents

File	Size	Contents
data/train_0000.bin … data/train_0025.bin	~200 MB each, ~5.2 GB total	100M training tokens per shard (≈2.60B total)
data/val_0000.bin … data/val_0025.bin	small	held-out validation tokens (≈2.4M total)
tokenizer.json	<1 MB	byte-level BPE tokenizer, 32,000 vocabulary
state.json	small	resume state: shards written, per-source progress, file checksums
manifest.json	small	per-shard token counts, SHA-256 checksums, per-source statistics

Intended mix

The target mix was 70% text, 20% code, and 10% math.

Category	Source	Target tokens
Text	FineWeb-Edu, sample-10BT	6.7B
Text	Wikipedia, 20231101.en	0.3B
Code	StarCoderData: Python 0.6B, JavaScript 0.4B, Java 0.3B, C++ 0.3B, TypeScript 0.2B, Go 0.2B	2.0B
Math	OpenWebMath	1.0B

These 26 shards cover only part of that plan. Exact per-source counts for these shards are in manifest.json. The first shards were drawn with the same proportional sampling as the rest, so the ratios should be close to the target.

Format

• Each .bin file is a flat array of unsigned 16-bit integers (uint16, little-endian) holding token IDs.
• Each document ends with the token <|endoftext|> (ID 0). Documents are packed back to back, with no padding.
• Each training shard's documents are shuffled within that shard. Shard order is not shuffled.
• The tokenizer includes these special tokens, reserved for later fine-tuning: <|endoftext|> (0), <|system|>, <|user|>, <|assistant|>, <|end|>, <|pad|>.

Load a shard without reading it all into memory:

import numpy as np
from tokenizers import Tokenizer

tokens = np.memmap("data/train_0000.bin", dtype=np.uint16, mode="r")
tok = Tokenizer.from_file("tokenizer.json")
print(tok.decode(tokens[:60].tolist(), skip_special_tokens=False))

Processing

1. Filtering. Text documents must be 200 to 200,000 characters, and at least 50% of their first 5,000 characters must be letters. Code files must be 50 to 1,000,000 characters, with at least 25% alphanumeric characters in their first 5,000, and no line longer than 1,000 characters. Math documents must be 200 to 200,000 characters.
2. Exact deduplication. Each document is hashed with BLAKE2b (8 bytes). Exact duplicates are dropped. The hash set resets at the start of each session, so duplicates across sessions may remain.
3. Decontamination. Documents sharing any 13-word sequence with the test or validation sets of GSM8K, HumanEval, HellaSwag, ARC-Easy, or ARC-Challenge are dropped. The reference set had about 1.45M hashed 13-grams.
4. Tokenization. Byte-level BPE, 32,000 vocabulary. Digits are split into single tokens. Trained on about 42,000 sampled documents (8,000 math, 20,000 FineWeb-Edu, 4,000 Wikipedia, and smaller samples of each code language). Measured compression on the sample: 4.20 characters per token for text, 3.10 for code, and 3.38 for math.
5. Validation split. Every 1,000th document goes to the validation files, about 0.1% of the data. Validation documents are never in the training shards.

Limitations

• Partial corpus. Only about a quarter of the planned 10B tokens. Do not treat this repository as complete.
• Deduplication is exact-only, and it resets each session. Near-duplicates (for example MinHash) were not removed in this part, though FineWeb-Edu was already deduplicated upstream.
• Quality filtering is heuristic. The only quality classifier is the one applied upstream by FineWeb-Edu.
• Web and code data can contain personal information, offensive text, and insecure code. No PII removal or toxicity filtering was applied in this part.
• Mostly English. Code is limited to six languages.

Licensing and attribution

This corpus combines several sources, each under its own license. Check every upstream dataset page before you redistribute or publish a model trained on it.

• FineWeb-Edu and OpenWebMath are released under ODC-By 1.0 according to their dataset pages.
• Wikipedia is released under CC BY-SA 4.0 and GFDL.
• StarCoderData is gated. Accepting its terms is required to access it. It contains code under per-file permissive licenses.

The repository is private. Set the license field to match your redistribution plans before making it public.

Citations

• Penedo et al. (2024). The FineWeb Datasets: Decanting the Web for the Finest Text Data at Scale.
• Li et al. (2023). StarCoder: may the source be with you!
• Paster et al. (2023). OpenWebMath: An Open Dataset of High-Quality Mathematical Web Text.
• Hoffmann et al. (2022). Training Compute-Optimal Large Language Models. (Chinchilla scaling, which set the 10B-token target.)