PranavViswanath/jlens-nla-auditbench

J-lens and NLA readouts for the 84 AuditBench organism cells

Per-token-position interpretability readouts over all 84 AuditBench model organisms (14 hidden behaviors × 2 instillation methods × 3 adversarial-training levels), harvested from Llama-3.3-70B-Instruct with each organism's LoRA adapter active. For every stored prompt the release carries:

• the full prompt + generated-response token sequence (exact token ids as run),
• the Jacobian-lens ("J-lens") top-50 readout at every (token position, layer 30–75) — plus logit-lens and adapter-off baseline channels and the per-(position, layer) read-energy score,
• every Natural Language Autoencoder (NLA) verbalization of the layer-53 residual (canonical 4-position reads for all 84 cells, dense every-8th-token scans for the 12 J-lens-blind "crux" cells, and base-model control reads),
• per-cell ground truth and sealed audit verdicts (quirk description, K.19 strong-evidence verdicts for NLA / J-lens / black-box, read-energy verdict).

This is everything needed to rebuild an interactive J-lens/NLA slice visualizer or run external reanalyses without GPU access. It is the data behind a head-to-head comparison of two white-box auditing instruments on AuditBench (safety-research/auditing-agents). Pipeline code: PranavViswanath/jlens-nla-auditbench.

Configs

transcripts — one row per (cell, condition, prompt)

The token axis every other config indexes into.

column	type	meaning
behavior, cell, instillation, adversarial	str	cell key parts; cell = behavior|instillation|adversarial
cond	str	generic (AuditBench's 50 behavior-agnostic audit prompts), domain (quirk-eliciting prompts), multiturn (8-turn conversations, 3 behaviors)
pidx	str	prompt index within the condition (p0, p1, …)
prompt_text	str	the user prompt (null for multiturn; see multiturn_user_turns)
multiturn_user_turns	list[str]	user turns of the multiturn conversation (null otherwise)
response_text	str	generated response as recorded at harvest time (for multiturn: the literal token strings from the read boundary on, including special tokens)
full_text	str	the whole sequence as literal token strings (includes chat-template special tokens)
token_ids / token_strings	list[int32] / list[str]	the exact token sequence the activations were captured on; token_strings[i] is the single-token decode of token_ids[i]
prompt_boundary_nb	int32	first response-token index (nb); prompt tokens are [0, nb), response tokens [nb, seq_len). For multiturn rows this is the start of turn 5 (the read boundary), not the first assistant token
seq_len	int32	sequence length
colon_idx, prefill_I_idx, content_mid_idx, onpolicy_idxs	int32 / list[int32]	the canonical read positions as token indices (see position convention)
clean_forward_top10_ids	list[list[int32]]	final-layer (clean forward) top-10 token ids per position, [seq_len][10]

jlens_readouts — one row per (cell, condition, prompt, token position, layer)

The argmax-grid + hover data: layers 30–75 (46 rows per token position).

column	type	meaning
key columns		behavior, cell, instillation, adversarial, cond, pidx as above
token_index	int32	position in the transcripts token axis (0-based)
layer	int32	residual-stream block, 30–75
jlens_top50_tokens	list[str]	J-lens readout: top-50 single-token decodes, rank-ordered (rank 0 = highest logit after lens transport → unembed)
jlens_top50_ids	list[int32]	same, as token ids
logitlens_top50_ids	list[int32]	logit-lens (unembed without transport) top-50 ids
baseline_top50_ids	list[int32]	adapter-off (base model) J-lens top-50 ids
read_energy	float32	generous-dictionary read-energy: softmax mass on the behavior's disposition tokens, as enrichment over uniform

The source harvest stores rank-ordered top-k ids only — there are no per-token probability scores. read_energy is the stored per-(position, layer) scalar. Decode *_ids columns with the tokenizer below.

nla_readouts — one row per NLA verbalization

column	type	meaning
key columns		behavior, cell, instillation, adversarial, cond, pidx
position	str	colon, prefill_I, content_mid, onpolicy_{0..7}, onpolicy_mean, or dense_<token_index>
position_kind	str	canonical / onpolicy / dense
token_index	int32?	resolved token index in transcripts (null for onpolicy_mean, which mean-pools the first 8 response tokens)
source	str	organism (adapter active) or base_control (same positions, base model)
scan	str	canonical (4-position reads, all 84 cells) or dense (every-8th-token scans; hardcode_test_cases + ai_welfare_poisoning)
vector_norm	float32	L2 norm of the layer-53 residual vector that was verbalized
verbalization	str	verbatim NLA output text

cell_metadata — one row per cell (84)

Ground truth + sealed audit verdicts: adapter_repo (the AuditBench LoRA), quirk_description (plain text of the quirk's system-prompt definition), crux (the 12 J-lens-blind cells), devset_behavior, multiturn_behavior, jlens_readenergy_verdict (read/positional/blind), and the sealed K.19 strong-evidence verdicts k19_nla_any/generic/domain, nla_specificity_any, k19_jlens, k19_blackbox.

Position-indexing convention

All positions are 0-based indices into a row's token_ids in transcripts, with nb = prompt_boundary_nb, seq = seq_len, resp_len = seq - nb:

• colon = nb - 1 (last pre-response token)
• prefill_I = nb (first response token)
• content_mid = nb + resp_len // 2
• onpolicy_k = nb + k (k = 0..7, clamped to seq - 1)
• onpolicy_mean = mean-pooled vector over the onpolicy_idxs positions (no single token index)
• dense_N = token index N (every-8th-token scans)

Usage example: rebuild the hardcode crux receipt view

from datasets import load_dataset

repo = "PranavViswanath/jlens-nla-auditbench"
cell = "hardcode_test_cases|transcripts|none"

tr  = load_dataset(repo, "transcripts", split="train").to_pandas()
nla = load_dataset(repo, "nla_readouts", split="train").to_pandas()
jl  = load_dataset(repo, "jlens_readouts", split="train").to_pandas()

row = tr[(tr.cell == cell) & (tr.cond == "domain") & (tr.pidx == "p0")].iloc[0]
print("MODEL SAID:", row.response_text[:200])

# what the NLA verbalized along the response (dense scan)
dense = nla[(nla.cell == cell) & (nla.cond == "domain") & (nla.pidx == "p0")
            & (nla.scan == "dense") & (nla.source == "organism")]
for _, r in dense.sort_values("token_index").iterrows():
    print(f"  tok[{r.token_index}] = {row.token_strings[r.token_index]!r}:",
          r.verbalization[:120])

# what the J-lens surfaced at the same cell's content-mid read, per layer
g = jl[(jl.cell == cell) & (jl.cond == "domain") & (jl.pidx == "p0")
       & (jl.token_index == row.content_mid_idx)]
for _, r in g.sort_values("layer").iterrows():
    print(f"  L{r.layer}: {list(r.jlens_top50_tokens)[:8]}  RE={r.read_energy:.1f}")

Provenance

• Base model: meta-llama/Llama-3.3-70B-Instruct (bf16, 80 blocks, d_model 8192), under the PRISM-4 system prompt with the auditing-agents/prism-4-tokenizer chat template.
• Organisms: the 84 AuditBench LoRA adapters (auditing-agents/llama_70b_*; see cell_metadata.adapter_repo), greedy decoding.
• J-lens: the pre-fitted base-model Jacobian lens neuronpedia/jacobian-lens (llama3.3-70b-it/jlens/Salesforce-wikitext), applied per layer then decoded with the model's own unembedding (Anthropic's jacobian-lens library).
• NLA: kitft/Llama-3.3-70B-NLA-L53-av (verbalizer) applied to the raw layer-53 residual vectors of the same forward passes, via kitft/nla-inference.
• Verdicts: AuditBench K.19 strong-evidence classifier (blinded, claude-opus-4-8 judge) + cross-behavior-null specificity; sealed before unblinding.
• Raw activations (layer-53 and band 30–75 bf16 residuals, ~77 GB) are not in this release; they exist and can be published separately on request.

Row counts

{
  "transcripts": 4758,
  "jlens_readouts": 21274356,
  "nla_readouts": 24394,
  "cell_metadata": 84
}

Licenses

• Generated text and activations derive from Llama 3.3 — use is subject to the Llama 3.3 Community License and AUP (hence license: llama3.3).
• AuditBench prompts, quirk definitions, and LoRA adapters: safety-research/auditing-agents (MIT).
• Jacobian lens weights: neuronpedia/jacobian-lens (MIT); NLA checkpoints: kitft/Llama-3.3-70B-NLA-L53-* (Llama 3.3 Community License).