CamStories-10k

Corpus of cleaned children’s stories from combining TinyStories' GPT-4 variant and SimpleStories with a fixed 10,000-token uncased word vocabulary, plus per-token half-second audio vectors at 8 kHz for audio-interpretable modelling.

Links: CamStories-10k • Full set and original 24 kHz Kokoro generations: CamStories_full

---

Model trained on CamStories-10k:

Dataset creation pipeline:

---

Files in this repo

• camstories_10000.parquet — stories and metadata. Single table with a split column equal to train or validation.
• tokens_audio_10k.parquet — per-token audio table. Stores 4096-length float vectors (half-second mono PCM at 8 kHz, RMS normalised).
• vocab.json — uncased 10,000-token vocabulary in JSON (token -> id) format.
• .gitattributes, README.md.

---

Dataset summary

• Domain: short fiction with simple language
• Token unit: word level, case-insensitive (dataset text is cased, vocab is uncased, the tokenizer lowercases before lookup)
• Vocabulary size: 10,000
• Splits stored as a column, not separate files
• Audio coverage: one vector per vocabulary item, the unknown token has no audio vector
• Sizes: train 3,622,986 rows, validation 36,067 rows

camstories_10000.parquet fields

• id int64
• story string
• origin string in {TinyStories, SimpleStories}
• split string in {train, validation}
• flesch_kincaid_grade float64

tokens_audio_10k.parquet fields

• token string (uncased)
• 4096_vec list[float64] — audio embedding vector (8 kHz mono, length 4096 samples)

---

Comparative statistics

Dataset	#Stories	Distinct Words	Reading Level	Story Length
TinyStories	Train: 2,717,495, Val: 27,630	41,546	2.39±1.26	192.4±83.2
SimpleStories	Train: 2,115,696, Val: 21,371	44,885	3.77±1.22	274.2±129.0
CamStories-Full	Train: 4,033,134, Val: 40,183	31,244	3.03±1.22	214.7±92.5
CamStories-10k	Train: 3,622,986, Val: 36,067	10,000	2.95±1.19	208.7±88.3

Statistics for TinyStories, SimpleStories, and CamStories variants. TinyStories and SimpleStories report a small vocabulary via subword tokenisation, but word-level tokenisation reveals larger vocabularies. CamStories-Full reduces the word set through consistent formatting and outlier removal. CamStories-10k fixes (V = 10{,}000) to enable word-level training. Flesch–Kincaid grade computed with textstat.

---

Gender-neutral name replacement

Name	Male Rating	Female Rating	#Ratings	#Occurrences
Alex	62%	38%	1,022	2,027,731
Billie	33%	67%	160	2,028,880
Casey	50%	50%	513	2,027,992
Finley	64%	36%	251	2,031,493
Frankie	52%	48%	170	2,029,157
Jamie	47%	53%	574	2,032,320
Luca	63%	37%	445	2,032,989
Quinn	54%	46%	455	2,031,503
Remy	36%	64%	121	2,032,832
Riley	53%	47%	869	2,033,078

Ten gender-neutral replacement names with perceived gender ratings from Behind the Name, and post-replacement counts in CamStories-10k. Frequencies are near-uniform to stabilise training while preserving original pronouns.

---

Load with 🤗 Datasets

Stories

from datasets import load_dataset

# Load all rows, then filter by the logical split column
ds_all = load_dataset("Piros/CamStories-10k", split="train")

ds_train = ds_all.filter(lambda ex: ex["split"] == "train")
ds_val   = ds_all.filter(lambda ex: ex["split"] == "validation")

print(ds_train[0]["story"][:200])

Streaming

from datasets import load_dataset

ds_stream = load_dataset("Piros/CamStories-10k", split="train", streaming=True)
train_iter = (ex for ex in ds_stream if ex["split"] == "train")
val_iter   = (ex for ex in ds_stream if ex["split"] == "validation")

---

Tokeniser that normalises case

The dataset is cased and the vocabulary is uncased, so the tokenizer lowercases before lookup.

import json
from pathlib import Path

# Load uncased vocab from vocab.json (token -> id mapping)
vocab = json.loads(Path("vocab.json").read_text())
stoi = {tok: idx for tok, idx in vocab.items()}
itos = {idx: tok for tok, idx in vocab.items()}

unk_id = stoi.get("<unk>", 0)  # fallback if not present

def encode(text):
    return [stoi.get(tok.lower(), unk_id) for tok in text.split()]

def decode(ids):
    return " ".join(itos.get(i, "<unk>") for i in ids)

---

Using the 10k word list in PyTorch

import torch
from torch.utils.data import DataLoader

pad_id = 0
max_len = 512

def collate(batch):
    ids = [encode(ex["story"])[:max_len] for ex in batch]
    lens = torch.tensor([len(x) for x in ids])
    maxL = int(lens.max())
    x = torch.full((len(ids), maxL), pad_id, dtype=torch.long)
    for i, seq in enumerate(ids):
        x[i, :len(seq)] = torch.tensor(seq)
    return {"input_ids": x, "lengths": lens}

ds_train = ds_train.with_format("python")
dl = DataLoader(ds_train, batch_size=32, shuffle=True, collate_fn=collate)
batch = next(iter(dl))
print(batch["input_ids"].shape)

---

Attaching per-token audio vectors

tokens_audio_10k.parquet stores the 4096-length vectors directly.

from datasets import load_dataset

ds_audio = load_dataset("Piros/CamStories-10k", data_files="tokens_audio_10k.parquet", split="train")
token_to_vec = {row["token"]: row["4096_vec"] for row in ds_audio}

# Example: get the vector for a token, lowercasing to match the audio table
vec = token_to_vec.get("alex")
assert vec is None or len(vec) == 4096

If you need the original high-rate Kokoro audio at 24 kHz, use CamStories-Full.

---

Intended uses

• Training and evaluating small decoder-only models with a fixed uncased word vocabulary
• Audio-interpretable studies where hidden states can be listened to
• Benchmarking with model-as-a-judge or interpretability tasks

Limitations

• Fixed vocabulary limits lexical variety at inference
• Fiction domain only
• <unk> has no audio vector (I set it to zero vector manually)

---

Dataset performance

We evaluate CamStories using model-as-a-judge on four axes: grammar, coherence, quality, originality. Two settings are reported.

Subword tokenisation. All models use the same SimpleStories tokenizer (link) and identical training hyperparameters. CamStories-Full and CamStories-10k achieve comparable grammar and coherence to SimpleStories, with quality on par and originality slightly lower due to reduced lexical variety.

Word tokenisation. With fixed $V=10{,}000$ word tokens, CamStories-10k improves grammar, coherence, and quality over TinyStories and SimpleStories; originality remains higher for SimpleStories given its broader language.

Training setup (shared across datasets). Decoder-only transformer trained from scratch:

• parameters ≈ 59.0M; 12 layers; 8 heads; d_model = 512; context = 512
• positional encoding: RoPE with $\theta=10{,}000$
• optimiser: AdamW, $\beta_1=0.9$, $\beta_2=0.95$, weight decay 0.1
• learning rate 6e-4, warmup 500 steps, decay to 6e-5 by 7,500 steps
• batch size 128, gradient clip 1.0, dropout 0
• dtype bfloat16, device CUDA
• max training steps 7,500; evaluation every 500 steps

All runs use the same tokeniser within each setting: the SimpleStories subword tokenizer for subword experiments, and whitespace word tokenisation for the 10k vocabulary runs.

Licence

cdla-sharing-1.0 due to the use of TinyStories and SimpleStories.

---

Citation

@dataset{camstories10k_2025,
  title  = {CamStories-10k},
  author = {Heijnen, Hidde and Körner, Paulina},
  year   = {2025},
  url    = {https://huggingface.co/datasets/Piros/CamStories-10k}
}

Acknowledgements: TinyStories, SimpleStories, DistilBERT NER, Behind the Name, language_tool, textstat, Kokoro TTS, Rubber Band, Hugging Face tokenisers.