k1/data.py

# -*- coding: utf-8 -*-
"""Data for K1.

Build once:
    python -m k1.data --build --out data/ --dataset tinystories
    python -m k1.data --build --out data/ --synthetic          # offline/tests

Cache layout: {out}/train.npy, {out}/val.npy (uint16 [N, seq_len]),
{out}/meta.json ({vocab, seq_len, dataset}). Representation A is built at
train time: x = E[ids] + tau * N(0, I) with E the frozen unit-RMS lookup
table donated by the discrete-AR anchor (online Gaussian dequantization).
"""
import argparse
import hashlib
import json
import os

import numpy as np
import torch


TINYSTORIES_REPO = "roneneldan/TinyStories"
TINYSTORIES_REVISION = "f54c09fd23315a6f9c86f9dc80f725de7d8f9c64"
GPT2_TOKENIZER_REPO = "gpt2"
GPT2_TOKENIZER_REVISION = "607a30d783dfa663caf39e06633721c8d4cfcd7e"


def _sha256(path):
    h = hashlib.sha256()
    with open(path, "rb") as f:
        for chunk in iter(lambda: f.read(1024 * 1024), b""):
            h.update(chunk)
    return h.hexdigest()


def _write_meta(out, metadata):
    train_path = os.path.join(out, "train.npy")
    val_path = os.path.join(out, "val.npy")
    metadata = dict(metadata)
    metadata["train_sha256"] = _sha256(train_path)
    metadata["val_sha256"] = _sha256(val_path)
    metadata["train_sequences"] = int(np.load(train_path, mmap_mode="r").shape[0])
    metadata["val_sequences"] = int(np.load(val_path, mmap_mode="r").shape[0])
    with open(os.path.join(out, "meta.json"), "w", encoding="utf-8") as f:
        json.dump(metadata, f, indent=1, sort_keys=True)
        f.write("\n")


def _prepare_output(out, force=False):
    paths = [os.path.join(out, n) for n in ("train.npy", "val.npy", "meta.json")]
    existing = [p for p in paths if os.path.exists(p)]
    if existing and not force:
        raise FileExistsError(
            "refusing to overwrite an existing data build: " + ", ".join(existing)
        )
    os.makedirs(out, exist_ok=True)


def build_synthetic(out, vocab=1024, seq_len=64, n_train=32768, n_val=4096,
                    seed=0, force=False):
    rng = np.random.default_rng(seed)
    p = 1.0 / np.arange(1, vocab + 1) ** 1.1
    p /= p.sum()
    _prepare_output(out, force)
    np.save(os.path.join(out, "train.npy"),
            rng.choice(vocab, size=(n_train, seq_len), p=p).astype(np.uint16))
    np.save(os.path.join(out, "val.npy"),
            rng.choice(vocab, size=(n_val, seq_len), p=p).astype(np.uint16))
    _write_meta(out, {
        "vocab": vocab, "seq_len": seq_len, "dataset": "synthetic",
        "seed": seed, "n_train": n_train, "n_val": n_val,
    })


def build_tinystories(out, seq_len=64, max_train_tokens=200_000_000,
                      max_val_tokens=5_000_000, force=False):
    from datasets import load_dataset          # lazy: needs network on first run
    from transformers import GPT2TokenizerFast

    _prepare_output(out, force)
    tok = GPT2TokenizerFast.from_pretrained(
        GPT2_TOKENIZER_REPO, revision=GPT2_TOKENIZER_REVISION
    )
    eos = tok.eos_token_id

    def pack(split, cap):
        ds = load_dataset(
            TINYSTORIES_REPO, revision=TINYSTORIES_REVISION, split=split
        )
        buf, total = [], 0
        for i in range(0, len(ds), 1000):
            for ids in tok(ds[i : i + 1000]["text"])["input_ids"]:
                a = np.asarray(ids + [eos], dtype=np.uint16)
                buf.append(a)
                total += a.size
            if total >= cap:
                break
        flat = np.concatenate(buf)[: (min(total, cap) // seq_len) * seq_len]
        return flat.reshape(-1, seq_len)

    np.save(os.path.join(out, "train.npy"), pack("train", int(max_train_tokens)))
    np.save(os.path.join(out, "val.npy"), pack("validation", int(max_val_tokens)))
    _write_meta(out, {
        "vocab": len(tok), "seq_len": seq_len, "dataset": "tinystories",
        "dataset_repo": TINYSTORIES_REPO,
        "dataset_revision": TINYSTORIES_REVISION,
        "tokenizer_repo": GPT2_TOKENIZER_REPO,
        "tokenizer_revision": GPT2_TOKENIZER_REVISION,
        "max_train_tokens": int(max_train_tokens),
        "max_val_tokens": int(max_val_tokens),
    })


def meta(data_dir):
    return json.load(open(os.path.join(data_dir, "meta.json")))


class Tokens(torch.utils.data.Dataset):
    def __init__(self, data_dir, split):
        self.a = np.load(os.path.join(data_dir, f"{split}.npy"), mmap_mode="r")

    def __len__(self):
        return self.a.shape[0]

    def __getitem__(self, i):
        return torch.from_numpy(self.a[i].astype(np.int64))


def get_loader(data_dir, split, batch, seed=0, shuffle=True):
    g = torch.Generator().manual_seed(seed)
    return torch.utils.data.DataLoader(
        Tokens(data_dir, split), batch_size=batch, shuffle=shuffle,
        drop_last=True, generator=g, num_workers=2, pin_memory=True)


def load_embedding(path, device):
    e = torch.from_numpy(np.load(path)).float().to(device)
    return e


def make_latents(ids, emb, tau, gen=None):
    """Representation A: frozen lookup + online Gaussian dequantization."""
    x = emb[ids]
    if tau > 0:
        x = x + tau * torch.randn(x.shape, generator=gen, device=x.device,
                                  dtype=x.dtype)
    return x


def nn_decode(x, emb):
    """Prefix-local nearest-neighbour readout: argmax_y <x, e_y> - ||e_y||^2/2."""
    score = x @ emb.T - 0.5 * emb.pow(2).sum(-1)
    return score.argmax(-1)


if __name__ == "__main__":
    ap = argparse.ArgumentParser()
    ap.add_argument("--build", action="store_true")
    ap.add_argument("--out", default="data")
    ap.add_argument("--dataset", default="tinystories")
    ap.add_argument("--synthetic", action="store_true")
    ap.add_argument("--seq_len", type=int, default=64)
    ap.add_argument("--max_train_tokens", type=float, default=2e8)
    ap.add_argument("--max_val_tokens", type=float, default=5e6)
    ap.add_argument("--force", action="store_true")
    a = ap.parse_args()
    if a.build and a.synthetic:
        build_synthetic(a.out, seq_len=a.seq_len, force=a.force)
    elif a.build:
        if a.dataset != "tinystories":
            raise SystemExit(f"unsupported --dataset {a.dataset!r}; expected tinystories")
        build_tinystories(a.out, a.seq_len, int(a.max_train_tokens),
                          int(a.max_val_tokens), force=a.force)
    print(json.dumps(meta(a.out)))