Datasets:

Monster-Code
/

Stew-10B-tokenized

---
license: other
task_categories:
- text-generation
language:
- en
size_categories:
- 1B<n<10B
pretty_name: Stew-10B
tags:
- pretraining
- gpt2
- tokenized
- pre-tokenized
configs:
- config_name: default
  data_files:
  - split: train
    path: data/*.parquet
---
![a4eabb77-0b9b-447b-a344-aaeaeb181821](https://cdn-uploads.huggingface.co/production/uploads/6a5f8c87a38cac087c2c6c05/O1nffJZXpsyWSmhjVhKBs.jpeg)

# Stew-10B

A 10-billion-token pretraining dataset for language models, already tokenized and ready to feed straight into a training loop.

## "Why am I just seeing numbers?"

If you opened the dataset viewer and saw rows that look like this:

```
[464, 2159, 3666, 318, 257, 1332, 286, 262, ...]
```

...that's not a bug. **This dataset doesn't contain text — it contains the token IDs that text was converted into.**

Here's what's going on. Before a language model can learn from text, every word (or piece of a word) has to be mapped to a number using a "tokenizer." The sentence `"The world"` becomes something like `[464, 995]` using the GPT-2 tokenizer. Models don't read letters — they read these integer IDs.

Most datasets on the Hub ship the raw text and leave tokenization to you. That works, but tokenizing 10 billion tokens worth of text takes **hours of CPU time** every time someone starts a training run. It's wasted work, repeated by everyone.

**Stew-10B skips that step.** The text has already been tokenized once, using the standard GPT-2 tokenizer, and the resulting integer IDs are what's stored here. You get:

- **Instant training startup** — no tokenization phase, just load and train
- **Deterministic data** — every user sees the exact same token stream, so experiments are reproducible
- **Smaller download** — token IDs compress better than raw UTF-8 text

The tradeoff is that the data is no longer human-readable in the viewer. If you want to see what a row actually says, you decode it:

```python
from transformers import AutoTokenizer
tok = AutoTokenizer.from_pretrained("gpt2")
print(tok.decode([464, 2159, 3666, 318, 257, 1332, 286, 262]))
# -> "The World My is a test of the"
```

## What's actually in each row

Each row in the parquet files contains **one training window of exactly 2,048 tokens** under the column `input_ids`. That's roughly 1,500 words of English text per row, which is a standard context length for pretraining smaller GPT-style models.

Rows are packed back-to-back from the original token stream, with documents separated by the special `<|endoftext|>` marker (token ID `50256`). So within a single row you might find the end of one Wikipedia article, the EOS token, and then the start of a web page — this is the standard "packed sequences" format used by nanoGPT, GPT-NeoX, Megatron, and basically every modern pretraining codebase.

## Where the text came from

Stew-10B is a careful mix of three well-known English pretraining corpora, blended at the token level to hit exact proportions:

| Source | Share | Tokens | What it is |
|---|---|---|---|
| [`wikimedia/wikipedia`](https://huggingface.co/datasets/wikimedia/wikipedia) (`20231101.en`) | 25% | 2.5B | Clean, encyclopedic English — the "high-quality" anchor |
| [`openbmb/Ultra-FineWeb`](https://huggingface.co/datasets/openbmb/Ultra-FineWeb) (English split) | 50% | 5.0B | Filtered Common Crawl — broad coverage of the open web |
| [`mlfoundations/dclm-baseline-1.0`](https://huggingface.co/datasets/mlfoundations/dclm-baseline-1.0) | 25% | 2.5B | DataComp-LM baseline — aggressively filtered web text |

The mix is designed to balance **quality** (Wikipedia), **diversity** (FineWeb), and **scale-trained signal** (DCLM) in roughly the proportions that have been shown to work well in recent small-model pretraining recipes.

## How to use it

### Option 1: Hugging Face `datasets` (easy mode)

```python
from datasets import load_dataset
ds = load_dataset("Monster-Code/Stew-10B-tokenized", split="train", streaming=True)
for row in ds:
    tokens = row["input_ids"]   # a list of 2048 integers
    # ...feed into your model
    break
```

Streaming is recommended because the full dataset is around 25 GB and you probably don't want all of it on disk at once.

### Option 2: Raw binary files (fast mode)

If you're running something like nanoGPT and want zero-overhead access, there's a second copy of the data stored as raw `uint16` binary files under `data_bin/`. These are flat token streams you can memory-map directly:

```python
import numpy as np
from huggingface_hub import hf_hub_download
path = hf_hub_download(
    "Monster-Code/Stew-10B-tokenized",
    "data_bin/train-00000-of-00020.bin",
    repo_type="dataset",
)
tokens = np.memmap(path, dtype=np.uint16, mode="r")
print(tokens.shape)      # (500_000_000,)
print(tokens[:16])       # first 16 token IDs
```

Each `.bin` file holds 500 million tokens (1 GB), and there are 20 of them. Concatenated in order, they reconstruct the full 10-billion-token stream.

## File layout

```
Monster-Code/Stew-10B-tokenized/
├── data/                               ← the parquet files (what `datasets` loads)
│   ├── train-00000-of-00020.parquet
│   ├── train-00001-of-00020.parquet
│   └── ...  (20 files total)
└── data_bin/                           ← same tokens as raw uint16 binary
    ├── train-00000-of-00020.bin
    ├── train-00001-of-00020.bin
    └── ...  (20 files total)
```

Both folders contain the same tokens in the same order. Pick whichever format fits your pipeline.

## Technical details

- **Tokenizer:** `gpt2` (the fast / Rust implementation from `tokenizers`)
- **Vocabulary size:** 50,257
- **End-of-document marker:** `<|endoftext|>` (token ID `50256`), inserted after every document
- **Sequence length (parquet):** 2,048 tokens per row
- **Total tokens:** 10,000,000,000 (exact — enforced during the build)
- **Total parquet rows:** approximately 4,882,812
- **Parquet schema:** `input_ids: fixed_size_list<int32>[2048]`
- **Parquet compression:** zstd level 3
- **Binary format:** little-endian `uint16`, no header, no padding

## Licensing

This dataset is a derivative work combining three upstream sources. **Each source retains its original license** — you are responsible for complying with all of them if you use this dataset:

- **Wikipedia** → CC BY-SA 3.0 and GFDL ([details](https://huggingface.co/datasets/wikimedia/wikipedia))
- **Ultra-FineWeb** → see the [original dataset card](https://huggingface.co/datasets/openbmb/Ultra-FineWeb)
- **DCLM-baseline** → see the [original dataset card](https://huggingface.co/datasets/mlfoundations/dclm-baseline-1.0)

No additional restrictions are imposed by this repository, but the dataset is marked `license: other` because the upstream licenses are mixed and you need to read them yourself before any downstream use.

## Citation

If you use Stew-10B in research, please cite the three underlying datasets. This repository is a repackaging and does not claim original authorship of the text content.

	---
	license: other
	task_categories:
	- text-generation
	language:
	- en
	size_categories:
	- 1B<n<10B
	pretty_name: Stew-10B
	tags:
	- pretraining
	- gpt2
	- tokenized
	- pre-tokenized
	configs:
	- config_name: default
	data_files:
	- split: train
	path: data/*.parquet
	---

	![a4eabb77-0b9b-447b-a344-aaeaeb181821](https://cdn-uploads.huggingface.co/production/uploads/6a5f8c87a38cac087c2c6c05/O1nffJZXpsyWSmhjVhKBs.jpeg)

	# Stew-10B

	A 10-billion-token pretraining dataset for language models, already tokenized and ready to feed straight into a training loop.

	## "Why am I just seeing numbers?"

	If you opened the dataset viewer and saw rows that look like this:

	```
	[464, 2159, 3666, 318, 257, 1332, 286, 262, ...]
	```

	...that's not a bug. This dataset doesn't contain text — it contains the token IDs that text was converted into.

	Here's what's going on. Before a language model can learn from text, every word (or piece of a word) has to be mapped to a number using a "tokenizer." The sentence `"The world"` becomes something like `[464, 995]` using the GPT-2 tokenizer. Models don't read letters — they read these integer IDs.

	Most datasets on the Hub ship the raw text and leave tokenization to you. That works, but tokenizing 10 billion tokens worth of text takes hours of CPU time every time someone starts a training run. It's wasted work, repeated by everyone.

	Stew-10B skips that step. The text has already been tokenized once, using the standard GPT-2 tokenizer, and the resulting integer IDs are what's stored here. You get:

	- Instant training startup — no tokenization phase, just load and train
	- Deterministic data — every user sees the exact same token stream, so experiments are reproducible
	- Smaller download — token IDs compress better than raw UTF-8 text

	The tradeoff is that the data is no longer human-readable in the viewer. If you want to see what a row actually says, you decode it:

	```python
	from transformers import AutoTokenizer
	tok = AutoTokenizer.from_pretrained("gpt2")
	print(tok.decode([464, 2159, 3666, 318, 257, 1332, 286, 262]))
	# -> "The World My is a test of the"
	```

	## What's actually in each row

	Each row in the parquet files contains one training window of exactly 2,048 tokens under the column `input_ids`. That's roughly 1,500 words of English text per row, which is a standard context length for pretraining smaller GPT-style models.

	Rows are packed back-to-back from the original token stream, with documents separated by the special `<\|endoftext\|>` marker (token ID `50256`). So within a single row you might find the end of one Wikipedia article, the EOS token, and then the start of a web page — this is the standard "packed sequences" format used by nanoGPT, GPT-NeoX, Megatron, and basically every modern pretraining codebase.

	## Where the text came from

	Stew-10B is a careful mix of three well-known English pretraining corpora, blended at the token level to hit exact proportions:

	\| Source \| Share \| Tokens \| What it is \|
	\|---\|---\|---\|---\|
	\| [`wikimedia/wikipedia`](https://huggingface.co/datasets/wikimedia/wikipedia) (`20231101.en`) \| 25% \| 2.5B \| Clean, encyclopedic English — the "high-quality" anchor \|
	\| [`openbmb/Ultra-FineWeb`](https://huggingface.co/datasets/openbmb/Ultra-FineWeb) (English split) \| 50% \| 5.0B \| Filtered Common Crawl — broad coverage of the open web \|
	\| [`mlfoundations/dclm-baseline-1.0`](https://huggingface.co/datasets/mlfoundations/dclm-baseline-1.0) \| 25% \| 2.5B \| DataComp-LM baseline — aggressively filtered web text \|

	The mix is designed to balance quality (Wikipedia), diversity (FineWeb), and scale-trained signal (DCLM) in roughly the proportions that have been shown to work well in recent small-model pretraining recipes.

	## How to use it

	### Option 1: Hugging Face `datasets` (easy mode)

	```python
	from datasets import load_dataset

	ds = load_dataset("Monster-Code/Stew-10B-tokenized", split="train", streaming=True)

	for row in ds:
	tokens = row["input_ids"] # a list of 2048 integers
	# ...feed into your model
	break
	```

	Streaming is recommended because the full dataset is around 25 GB and you probably don't want all of it on disk at once.

	### Option 2: Raw binary files (fast mode)

	If you're running something like nanoGPT and want zero-overhead access, there's a second copy of the data stored as raw `uint16` binary files under `data_bin/`. These are flat token streams you can memory-map directly:

	```python
	import numpy as np
	from huggingface_hub import hf_hub_download

	path = hf_hub_download(
	"Monster-Code/Stew-10B-tokenized",
	"data_bin/train-00000-of-00020.bin",
	repo_type="dataset",
	)
	tokens = np.memmap(path, dtype=np.uint16, mode="r")
	print(tokens.shape) # (500_000_000,)
	print(tokens[:16]) # first 16 token IDs
	```

	Each `.bin` file holds 500 million tokens (1 GB), and there are 20 of them. Concatenated in order, they reconstruct the full 10-billion-token stream.

	## File layout

	```
	Monster-Code/Stew-10B-tokenized/
	├── data/ ← the parquet files (what `datasets` loads)
	│ ├── train-00000-of-00020.parquet
	│ ├── train-00001-of-00020.parquet
	│ └── ... (20 files total)
	└── data_bin/ ← same tokens as raw uint16 binary
	├── train-00000-of-00020.bin
	├── train-00001-of-00020.bin
	└── ... (20 files total)
	```

	Both folders contain the same tokens in the same order. Pick whichever format fits your pipeline.

	## Technical details

	- Tokenizer: `gpt2` (the fast / Rust implementation from `tokenizers`)
	- Vocabulary size: 50,257
	- End-of-document marker: `<\|endoftext\|>` (token ID `50256`), inserted after every document
	- Sequence length (parquet): 2,048 tokens per row
	- Total tokens: 10,000,000,000 (exact — enforced during the build)
	- Total parquet rows: approximately 4,882,812
	- Parquet schema: `input_ids: fixed_size_list<int32>[2048]`
	- Parquet compression: zstd level 3
	- Binary format: little-endian `uint16`, no header, no padding

	## Licensing

	This dataset is a derivative work combining three upstream sources. Each source retains its original license — you are responsible for complying with all of them if you use this dataset:

	- Wikipedia → CC BY-SA 3.0 and GFDL ([details](https://huggingface.co/datasets/wikimedia/wikipedia))
	- Ultra-FineWeb → see the [original dataset card](https://huggingface.co/datasets/openbmb/Ultra-FineWeb)
	- DCLM-baseline → see the [original dataset card](https://huggingface.co/datasets/mlfoundations/dclm-baseline-1.0)

	No additional restrictions are imposed by this repository, but the dataset is marked `license: other` because the upstream licenses are mixed and you need to read them yourself before any downstream use.

	## Citation

	If you use Stew-10B in research, please cite the three underlying datasets. This repository is a repackaging and does not claim original authorship of the text content.