| """Build a 300,000-sequence OpenWebText training corpus, disjoint from the |
| existing test split. |
| |
| Follows the conventions of eda_phase0/stage1_02b exactly, so the new corpus is |
| the same KIND of data as the 10,000-sequence train split it replaces: |
| * stream Skylion007/openwebtext with shuffle(seed=SEED, buffer=30,000) |
| * tokenise each document with truncation to 127 content tokens |
| * keep only documents that yield exactly 127 (i.e. long enough) |
| * prepend the BOS token to make a 128-token sequence |
| |
| DISJOINTNESS is enforced structurally at the end: any sequence byte-identical |
| to a test sequence is dropped and the count is reported. The test split is NOT |
| regenerated -- it stays exactly as shipped, so every number produced from this |
| corpus is directly comparable to the numbers already in the repo. |
| """ |
| from __future__ import annotations |
| import json, sys, time |
| from pathlib import Path |
| import numpy as np |
|
|
| HERE = Path(__file__).resolve().parent |
| ROOT = HERE.parent |
| sys.path.insert(0, str(ROOT / "eda_phase0")) |
| import config as C |
|
|
| TARGET = 300_000 |
| OUT = HERE / "corpus_300k.npz" |
|
|
|
|
| def main() -> None: |
| from transformers import AutoTokenizer |
| from datasets import load_dataset |
|
|
| tok = AutoTokenizer.from_pretrained("gpt2") |
| ds = load_dataset(C.OWT_DATASET, split="train", streaming=True) |
| ds = ds.shuffle(seed=C.SEED, buffer_size=C.OWT_SHUFFLE_BUFFER) |
|
|
| seqs: list[np.ndarray] = [] |
| pulled = discarded = 0 |
| t0 = time.time() |
| for ex in ds: |
| pulled += 1 |
| ids = tok(ex["text"], truncation=True, |
| max_length=C.OWT_CONTENT_TOKENS)["input_ids"] |
| if len(ids) == C.OWT_CONTENT_TOKENS: |
| seqs.append(np.asarray(ids, dtype=np.int32)) |
| else: |
| discarded += 1 |
| if pulled % 25_000 == 0: |
| print(f" pulled {pulled:,} kept {len(seqs):,} " |
| f"{(time.time()-t0)/60:.1f} min", flush=True) |
| if len(seqs) >= TARGET: |
| break |
|
|
| pool = np.stack(seqs) |
| full = np.zeros((len(pool), C.OWT_SEQ_LEN), dtype=np.int32) |
| full[:, 0] = C.BOS_TOKEN_ID |
| full[:, 1:] = pool |
| print(f"\nbuilt {len(full):,} sequences from {pulled:,} documents " |
| f"({discarded:,} too short), {(time.time()-t0)/60:.1f} min") |
|
|
| |
| te = np.load(C.CACHE / "owt_test_tokens.npz")["tokens"] |
| sig_te = set(map(bytes, np.ascontiguousarray(te))) |
| sig_seen: set[bytes] = set() |
| keep = np.ones(len(full), bool) |
| dup_test = dup_self = 0 |
| for i, row in enumerate(np.ascontiguousarray(full)): |
| b = bytes(row) |
| if b in sig_te: |
| keep[i] = False; dup_test += 1 |
| elif b in sig_seen: |
| keep[i] = False; dup_self += 1 |
| else: |
| sig_seen.add(b) |
| full = full[keep] |
| print(f"dropped {dup_test:,} duplicates of TEST and {dup_self:,} internal " |
| f"duplicates -> {len(full):,} sequences") |
|
|
| tr = np.load(C.CACHE / "owt_train_tokens.npz")["tokens"] |
| overlap_tr = len(set(map(bytes, np.ascontiguousarray(tr))) & |
| set(map(bytes, np.ascontiguousarray(full)))) |
| n_read = len(full) * (C.OWT_SEQ_LEN - C.FIRST_READ_POSITION) |
| print(f"contains {overlap_tr:,} of the original 10,000 train sequences " |
| f"(expected: it is a superset of the same stream)") |
| print(f"read positions: {n_read:,} " |
| f"({n_read / 1_270_000:.1f}x the shipped train corpus)") |
|
|
| np.savez_compressed(OUT, tokens=full) |
| (HERE / "corpus_info.json").write_text(json.dumps({ |
| "dataset": C.OWT_DATASET, "seed": C.SEED, |
| "shuffle_buffer": C.OWT_SHUFFLE_BUFFER, |
| "documents_pulled": pulled, "documents_too_short": discarded, |
| "sequences": int(len(full)), "seq_len": C.OWT_SEQ_LEN, |
| "read_positions": int(n_read), |
| "dropped_dup_of_test": dup_test, "dropped_dup_internal": dup_self, |
| "overlap_with_test": 0, "overlap_with_old_train": overlap_tr, |
| "test_split": "owt_test_tokens.npz, unchanged", |
| }, indent=2)) |
| print(f"wrote {OUT}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
