ceselder/muse-spark-olens-heldout-activations

Muse Spark Open oracle-lens held-out rows with layer 8-56 activations

Built with Muse Spark Open. The held-out file of the Muse Spark Open oracle-lens project (collection): 16,323 web-text positions of Muse Spark Open 816B-A42B with the model's residual-stream activation at seven layers (8, 16, 24, 32, 40, 48, 56; 8,192-d fp16) at each position, the exact next-token entropy and top-1 probability, and -- for the 7,569 "kept" rows -- Muse's own sampled continuation (the lens / reconstructor target); plus the dense held-out file: 126,250 positions (every prefilled position t >= 31 of the same windows) with h40, entropy and the document's TRUE next 16 tokens. Every number in the lens and reconstructor cards' "held-out" columns was computed on these rows; nothing here was ever trained on. With them you can score any text-to-activation reconstructor (at any of the seven layers) or any lens's bullets without booting the 533 GB model. Built 2026-10-26 from /vol/data/h40/heldout_s0.parquet and /vol/data/h40/dense_heldout_s0.parquet of the muse-olens Modal volume (decoded text columns added, row groups re-cut to 512 / 2,048 rows for the viewer; nothing dropped). Exact counts, byte sizes, norm and entropy statistics: stats.json.

file	rows	what	held out from
heldout_rows.parquet	16,323 (7,569 kept)	every held-out read position: metadata, decoded text, entropy, Muse's continuation, h40	the lens SFTs (both arms), the inverter, the reconstructors, the ridge map, the per-layer heads, the Qwen reader, the RL pools
heldout_multilayer.parquet	16,323	the same rows' h8, h16, h24, h32, h48, h56 (keyed by window, file, line, start, t)	same
dense_heldout_rows.parquet	126,250	every prefilled position t >= 31 of the same 2,048 windows: h40, entropy, top-1, the document's TRUE next 16 tokens	the dense (true next-16) reconstructor

How the rows were made

• Source: FineFineWeb file finance/finance_001578 (permutation index 4049 of our seed-4 file order; 4,015 documents / 8.3M tokens) -- the same held-out file our Kimi-K3 harvest used; disjoint from the 48 files (permutation index 5001+) the Muse harvest trained on. 2,048 windows of U[32, 1024] tokens at random document offsets, 8 read positions per window (every row of heldout_rows = one position; window, file, line, start, t identify it; ctx_ids = the window up to and including the position, plain token ids, no BOS, no template).
• Engine: vLLM nightly 0.32.1rc1.dev486 + vLLM PR #61879 + the vllm-metamodels muse-spark fork, TP8 on 8 x H200, NVFP4 experts as W4A16 Marlin, CUDA-graph decode, prefix caching. The fork's gated-residual fold materialises the TRUE output of each decoder layer (vLLM defers the last blend to the next layer) for the captured rows: h_L = the single residual stream leaving 0-based layer L (= transformers hidden_states[L+1]), fp32 in the engine, stored fp16. entropy / top1_prob come from the engine's own LM head on the layer-61 state (final norm -> lm_head -> x0.1768 -> softcap 20) at that position (argmax agrees with the engine's greedy token on 512/512 windows per group).
• Positions with entropy >= 1.6641 nats (the pilot median over 2,048 training windows; above_thr) got one T = 1 continuation by Muse (<= 16 tokens, cut at a special id / newline / * / |, dropped if < 4 tokens remain, then cut to a length drawn ~ U[4, 16]): kept = True, roll_ids / roll_text = the raw sample, bullet = the cut target text, bullet_ntok = its token count (the first bullet_ntok ids of roll_ids are the target ids), bullet_len_draw = the drawn length. In the held-out file every above-threshold position got a continuation (split = heldout for all rows).
• The dense file holds every prefilled position t >= 31 of the same windows (no entropy filter): h40, entropy, top1_prob and next16 = the document's actual next 16 tokens (the target of the dense reconstructor ablation; no sampling involved).

Columns

heldout_rows.parquet:

column	type	meaning
split	string	heldout (training rows carry sft / inv / rl, a document-level 68/22/10 split)
window, file, line, start, t, ctx_len, win_len	int / string	window index, source jsonl file + line, window offset in the document, read position inside the window (0-based), context length (= t + 1), window length
bos	bool	False everywhere: no `<
ctx_ids	list[int32]	Muse token ids of the context up to and including the read position
ctx_text, read_token	string	decoded context; the decoded token at the read position (added here)
next16, next16_text	list[int32], string	the document's actual next 16 tokens
entropy, top1_prob	float32	exact next-token entropy (nats) and top-1 probability of the base model at the position
above_thr, kept	bool	entropy >= 1.6641; above the threshold AND a valid continuation exists
roll_ids, roll_text	list[int32], string	Muse's raw T = 1 sample (<= 16 tokens) at the position
bullet, bullet_len_draw, bullet_ntok, continuation_text	string, int, int, string	the cut target text, the drawn length, its token count (roll_ids[:bullet_ntok] = target ids), the decoded target (added here)
h40_norm	float32
h40	fixed-size list[float16] (8192)	the stream leaving layer 40 = THE read vector of the lens, the reconstructors and the Qwen reader

heldout_multilayer.parquet: window, file, line, start, t + h8, h16, h24, h32, h48, h56 (fixed-size list[float16] (8192) each), same row order as heldout_rows.parquet. dense_heldout_rows.parquet: window, split, file, line, start, t, entropy, top1_prob, next16, next16_text, h40_norm, h40.

Scoring a reconstructor or a lens on these rows

• A reconstructor maps <|begin_of_text|> (id 200000) + roll_ids[:bullet_ntok] (or any text span) to an 8,192-d direction; compare it with h40 - mu by cosine (mu = the centre shipped with each reconstructor in ceselder/muse-spark-olens-reconstructor). The per-layer ridge heads there predict h8 .. h56 from the same span (compare with h_l - mu_l).
• A lens maps h40 to text; the training target is bullet, the held-out CE in the lens card is the token-mean cross-entropy of "* " + bullet + <|eot|> under the lens prompt with h40 injected at stream:41 (4,096 of the kept rows: 5.495 nats/token before training; see the lens card for the curves).
• The fp16 vectors are what the trainers saw. The Muse tokenizer (tokenizer.json of the base repo; HF tokenizers) decodes the id columns; plain encoding must not parse <|...|> strings as control tokens (split_special_tokens=True or encode_special_tokens=True).

Licence

Mixed, by column: the web text (ctx_*, next16*) is from m-a-p/FineFineWeb under its terms; the continuations (roll_*, bullet, continuation_text) are outputs of Muse Spark Open and the activations are derived from its weights, under the Muse Model License (LICENSE.md

• USE_POLICY.md, Meta's files verbatim; copyright (c) 2026 Meta Platforms, Inc.). Research use. Built with Muse Spark Open.

Provenance

src/muse_harvest.py of ceselder/muse-olens (commit 46b1c0b; the --do-heldout pass of shard s0 wrote both files at 02:41 UTC on 2026-10-26, before any training row); conversion by scripts/hf_publish_muse.py::dataset_heldout.