Delete ICLR dataset

ICLR dataset/README.md

@@ -1,216 +0,0 @@
-# `dataset3/` —— Fact Knowledge Stability Benchmark
-
-按 [`../dataset/fact_knowledge_stability_dataset_reconstruction.md`](../dataset/fact_knowledge_stability_dataset_reconstruction.md)
-从 `../dataset/` 的数据重建。**不改动 `../dataset/` 和 `../dataset2/`。**
-
-与 `dataset2` 的根本区别在方法论，不在数字：
-
-> **基准集是固定的 2,592 条，对所有模型相同。** `K_m` 只是每个模型的正确性**标签**，
-> 绝不用来从基准集里删事实（spec §2.1）。模型答错、一直答错、拒答、
-> 在不同条件下答不同答案——事实都留在集合里。
-
----
-
-## 目录
-
-```
-dataset3/
-├── configs/                     # 全部参数外置，脚本里不硬编码（spec §4.4, §18）
-│   ├── models.yaml              #   5 个过滤模型 + 评测模型 + 生成配置
-│   ├── relations.yaml           #   21 个基准关系 + 排除清单 + 两个开关
-│   ├── source_templates.yaml    #   原始来源、cloze 模板、别名资源
-│   └── eval_conditions.yaml     #   8 个条件的角色/目标槽/期望计数
-├── src/
-│   ├── common.py                    公共：配置/规范化/校验和/计数核对
-│   ├── build_candidate_known.py (I)   → candidate_known_8107.jsonl
-│   ├── enrich_facts.py         (II)   → enriched_facts_6180.jsonl
-│   ├── select_benchmark.py     (III)  → benchmark_facts_2592.jsonl
-│   ├── build_eval_bank.py      (IV)   → evaluation_queries_44418.jsonl
-│   ├── validate_facts.py              → validation_report.json  ← 硬门禁
-│   ├── build_stats.py                 → dataset_statistics.json
-│   ├── qualification_run.py    (V)    → qualification/<model>.jsonl   [GPU]
-│   ├── qualification_score.py  (V)    → known_labels.json
-│   ├── eval_run.py             (VI)   → evaluation/<model>.jsonl       [GPU]
-│   ├── eval_score.py           (VI)   → stability_report.json
-│   ├── filter_run.py                  阶段 I 首 token 过滤（重跑用）  [GPU]
-│   ├── scoring_full.py                五标签判分器
-│   ├── qual_templates.py              非基准关系的兜底问句
-│   └── test_scoring.py                31 条单元测试
-├── outputs/
-└── run_pipeline.sh              # build / gpu / score / report / all
-```
-
----
-
-## 六个阶段
-
-### I. 候选召回 → 8,107（spec §4）
-
-```
-1,783,541 cloze prompt
-   → 5 模型首 token argmax 取交集 → 10,601
-   → 丢弃 T-REx / Wikidata5M 子集，补 PopQA 378 → 8,107
-```
-
-**GPU 未重跑。** 那 1,783,541 × 5 次前向的逐条判定向量已存于
-`dataset/filter/correct_<model>.npy`。[build_candidate_known.py](src/build_candidate_known.py)
-重新读取 prompt 表、**重新求交集**、重新施加来源丢弃规则，并把每个输入文件的
-校验和写进 `stage1_report.json`——数字是**验证出来的**，不是照抄。
-另外与 `dataset/filter/global_known_clean.jsonl` 做集合相等性核对。
-要从零重跑推理用 `src/filter_run.py`。
-
-### II. 事实增强 → 6,180（spec §5）
-
-- **实体感知分组**：优先用实体 ID，无 ID 才退回规范化文本；**跨来源合并**
-  （1,036 组同时出现在 CounterFact 和 LAMA-TREx）。8,107 行 → 6,185 组
-- **函数型冲突丢弃 5 条**：同名不同人（两个 "Michael Vincent" 生于 1964/1976）问题本身无解。
-  判据严格——**缺实体 ID 不算"同一实体"的证据**，所有成员必须都有 ID 且一致才保留
-- **别名扩展**：对别名资源做**单次过滤扫描**（spec §5.3），不全量载入
-- **挂 canonical 问句**，与评测扰动模板严格分离（spec §16）
-
-### III. 基准选择 → 2,592 / 21 关系（spec §6）
-
-```
-6,180 → core 来源（CounterFact + LAMA-TREx + PopQA）→ 3,705
-      → 函数型（单值）关系 → 2,592
-```
-
-### IV. 查询库 → 44,416（spec §8–§12）
-
-| 条件 | 查询 | 事实 | 角色 |
-|---|---:|---:|---|
-| anchor | 2,592 | 2,592 | main |
-| multilingual | 12,010 | 2,402 | main |
-| paraphrase | 10,053 | 2,592 | main |
-| format | 7,776 | 2,592 | main |
-| context | **6,829** | 2,591 | main |
-| reverse | 634 | 253 | **结构分析，单独报** |
-| recognition | 3,412 | 2,585 | 诊断 |
-| reverse_illposed | 1,110 | 1,110 | 诊断 |
-| **合计** | **44,416** | | main forward **39,260** |
-
-每条查询自带 `use_for_main_forward` / `use_for_reverse_analysis` /
-`use_for_recognition_analysis` 三个布尔量，**由 `eval_conditions.yaml` 派生**，
-下游聚合不需要硬编码哪个条件进哪个平均。校验器会检查每行的布尔量与注册表一致。
-
-### V. Anchor 资格认证 → `K_m` 标签（spec §7）⬜ 待跑
-
-纯补全 prompt（base 与 instruct 用**完全相同**的字符串，无 chat template）、
-贪婪解码 24 token、无候选无 few-shot。判分在 CPU，**五标签**：
-
-`correct` / `incorrect` / `ambiguous` / `abstain` / `unparseable`
-
-输出 `known_labels.json`：`{fact_id: {model: label}}`，覆盖全部 2,592 × 全部模型。
-
-### VI. 扰动评测 → 稳定性 ⬜ 待跑
-
-[eval_run.py](src/eval_run.py) 跑全部 44,416 条查询，
-**解码配置与 anchor 完全一致**（同一份 `configs/models.yaml:generation`）——
-否则 `max_new_tokens` 或 chat template 的差异会被误读成稳定性效应。
-anchor 也一起重跑，让所有条件走同一条代码路径。
-
-[eval_score.py](src/eval_score.py) 在 CPU 判分并出报表，三条规则写死在代码里而不是留给读者：
-
-1. **按查询自带的布尔量分组** —— `recognition` 和 `reverse_illposed` 永不进主平均，
-   `reverse` 因为换了目标槽而单独报（spec §2.3）
-2. **两个分母并排报**：`fixed`（固定 2,592，spec §2.1）与
-   `anchored`（限定在该模型的 `K_m` 内，即条件化保持率）
-3. **每个数字按 `answer_in_subject_surface` 再拆一次**（`·real` / `·copy`），
-   因为 28.9% 的事实靠复制就能答对、天然接近满分（见 F1）
-
-主指标 macro = paraphrase / format / context / multilingual 四者均值：
-anchor 是基线不计入，reverse 换了槽不计入，两个诊断条件不计入。
-
----
-
-## 运行
-
-```bash
-cd /scratch/rds-fei-rsfm-rw/cshi0459/ICLR27/dataset3
-bash run_pipeline.sh build     # 阶段 I-IV + 校验 + 统计，CPU 约 1 分钟（已跑完）
-bash run_pipeline.sh gpu       # 阶段 V+VI 生成，每个模型只加载一次权重
-bash run_pipeline.sh score     # 阶段 V 判分 → K_m 标签
-bash run_pipeline.sh report    # 阶段 VI 判分 → stability_report.json
-```
-
-`gpu` 把 anchor 和扰动两趟生成合在一起跑，权重只载入一次。
-两个生成阶段都幂等：anchor 已存在会跳过，`eval_run.py --resume` 会跳过已完成的查询。
-
-**顺序要求**：`score` 必须在 `report` 之前跑，否则没有 `known_labels.json`，
-`anchored` 那一列会缺失（脚本会警告并只报 `fixed`）。
-
----
-
-## 当前状态
-
-| 阶段 | 状态 |
-|---|---|
-| I 候选召回 | ✅ 8,107，全部计数命中 |
-| II 事实增强 | ✅ 6,180，6,185 组 / 5 冲突 / 1,771 合并 / 1,036 跨来源，全中 |
-| III 基准选择 | ✅ 2,592 / 21 关系，全中 |
-| IV 查询库 | ✅ 44,416（见差异 D1） |
-| 校验 | ✅ **0 hard errors** |
-| 单元测试 | ✅ **31/31** |
-| V 资格认证 | ⬜ 待跑（判分逻辑已用合成数据演练通过） |
-| VI 扰动评测 | ⬜ 待跑（运行器 + 报表已用合成数据演练通过） |
-
----
-
-## 与 spec 的差异（完整版见 [outputs/reconstruction_differences.md](outputs/reconstruction_differences.md)）
-
-除一处外全部精确复现。
-
-**D1 — context 6,831 → 6,829，总计 44,418 → 44,416。**
-旧数据里有 2 条 context 查询的干扰实体字面包含 gold：
-`"...confuse States Reorganisation Act with **Indian** Act..."` 而 gold 是 `India`。
-违反 spec §9.4 与 §13.9。按 spec §10「发现既有缺陷可改数」处理：
-在建库时加**规则化守卫**（主语提及剔除后 gold 仍出现即丢弃），不是硬编码例外。
-
-**C1 — spec §6.2 与要求的规模自相矛盾。**
-§6.2 点名 `developer of` / `manufacturer of` 不适合，但这两个关系共 **846 条**，
-去掉只剩 1,746 条 / 19 关系，达不到 §15 验收要求的 2,592 / 21。
-处理：保留并打 `spec_6_2_flag`，`relations.yaml` 提供 `drop_spec_6_2_flagged` 开关
-可一键产出 1,746 条的合规变体。
-
-**F1 — 28.9% 的基准事实可以靠复制字符串答对。**
-2,592 条里有 **750 条** object 字面包含在 subject 名字里：
-
-```
-Airbus A318  → manufacturer  Airbus      (该关系 87.8% 命中)
-Adobe Acrobat → developer    Adobe        (49.1%)
-Amazon Music  → owned by     Amazon       (58.4%)
-```
-
-其中 586 条来自 manufacturer 和 developer——**独立印证了 C1**。
-这类事实"稳定"的原因与知识无关，会抬高所有保持率、削弱要研究的效应。
-按 spec §16 不删，打 `answer_in_subject_surface` 标记，事实和查询两级都带。
-`qualification_score.py` 已经**默认分开报**这两个子集的准确率。
-
-**F2 — 8,107 里有 808 条完全重复的三元组**（唯一四元组只有 7,299）。分组阶段自然吸收，仅记录。
-
-**N1 — Stage I 未重跑 GPU**（见上）。
-**N2 — `capital_of` 方向未归一化**：spec §2.2 要求单一方向，但归一化会改变规模，故保留
-`direction: inverse` + `inverse_of: capital` 显式标注，开关在 `relations.yaml`。
-
----
-
-## 两个必须记住的口径
-
-1. **分母永远是 2,592。** `K_m` 是标签不是筛子。加模型、换模型都不改任何已算出的数。
-2. **reverse 不进 main forward 平均。** 它换了目标槽（object → subject），
-   spec §2.3 要求单独报。`recognition` 和 `reverse_illposed` 同理，且校验器有硬检查。
-
----
-
-## 报告用描述（spec §17）
-
-> We first use five-model first-token consensus to retrieve high-probability
-> factual candidates from large-scale knowledge resources. We then merge
-> duplicate facts, expand entity aliases, construct independent canonical
-> questions, remove ambiguous and multi-valued relations, and obtain a fixed
-> benchmark of 2,592 facts across 21 relations. Model-specific open-ended anchor
-> generation provides correctness labels but does not alter the benchmark
-> denominator. Based on the fixed fact set, we construct 44,416 queries covering
-> anchor, paraphrastic, format, contextual, cross-lingual, reverse, and
-> recognition conditions, while isolating ill-posed reverse queries as a
-> separate diagnostic set.

ICLR dataset/configs/eval_conditions.yaml

@@ -1,162 +0,0 @@
-# Evaluation condition registry (spec sections 2.3, 8, 9, 10).
-#
-# The per-query booleans use_for_main_forward / use_for_reverse_analysis /
-# use_for_recognition_analysis are DERIVED from this file, so a downstream
-# aggregation never has to hard-code which conditions belong in which average.
-#
-# Spec 2.3 / 16: recognition and reverse_illposed must never enter the main
-# forward aggregation, and reverse is reported separately because it changes
-# the target slot from object to subject.
-
-conditions:
-  anchor:
-    role: main
-    target_slot: object
-    is_assisted: false
-    is_well_posed: true
-    use_for_main_forward: true
-    use_for_reverse_analysis: false
-    use_for_recognition_analysis: false
-    expected_queries: 2592
-    expected_facts: 2592
-    description: >
-      The canonical qualification question itself. Shares the prompt string with
-      the anchor qualification run, so per-condition retention is measured
-      against a real measured baseline rather than an assumed 1.0.
-
-  paraphrase:
-    role: main
-    target_slot: object
-    is_assisted: false
-    is_well_posed: true
-    use_for_main_forward: true
-    use_for_reverse_analysis: false
-    use_for_recognition_analysis: false
-    expected_queries: 10053
-    expected_facts: 2592
-    migrated_from: queryA_canonical
-    description: >
-      Lexical and syntactic rewording, same fact and same target slot.
-
-  format:
-    role: main
-    target_slot: object
-    is_assisted: false
-    is_well_posed: true
-    use_for_main_forward: true
-    use_for_reverse_analysis: false
-    use_for_recognition_analysis: false
-    expected_queries: 7776
-    expected_facts: 2592
-    migrated_from: queryB_paraphrase
-    excludes: [mcq]
-    description: >
-      Question or response format changes with no candidates exposed. MCQ rows
-      from the same source file are routed to `recognition` instead (spec 9.3).
-
-  context:
-    role: main
-    target_slot: object
-    is_assisted: false
-    is_well_posed: true
-    use_for_main_forward: true
-    use_for_reverse_analysis: false
-    use_for_recognition_analysis: false
-    expected_queries: 6831
-    expected_facts: 2591
-    migrated_from: queryD_context
-    description: >
-      Irrelevant or misleading context prepended; the intended query stays
-      unambiguous and the correct answer is unchanged.
-
-  multilingual:
-    role: main
-    target_slot: object
-    is_assisted: false
-    is_well_posed: true
-    use_for_main_forward: true
-    use_for_reverse_analysis: false
-    use_for_recognition_analysis: false
-    expected_queries: 12010
-    expected_facts: 2402
-    migrated_from: queryE_multilingual
-    languages: [zh, fr, es, de, ru]
-    description: >
-      Same factual question in another language. Query language is stored in
-      the `language` field.
-
-  reverse:
-    role: structural            # reported separately, NOT in the main average
-    target_slot: subject
-    is_assisted: false
-    is_well_posed: true
-    use_for_main_forward: false
-    use_for_reverse_analysis: true
-    use_for_recognition_analysis: false
-    expected_queries: 634
-    expected_facts: 253
-    migrated_from: queryC_reverse
-    requires: is_inverse_well_posed
-    description: >
-      (o, r^-1) -> s. Only built where the inverse mapping is unique. Spec 2.3:
-      reported separately because the target slot changes.
-
-  recognition:
-    role: diagnostic
-    target_slot: object
-    is_assisted: true
-    is_well_posed: true
-    use_for_main_forward: false
-    use_for_reverse_analysis: false
-    use_for_recognition_analysis: true
-    expected_queries: 3412
-    expected_facts: 2585
-    migrated_from: queryB_paraphrase(fmt=mcq)
-    description: >
-      Multiple choice. Measures recognition, not unaided retrieval.
-
-  reverse_illposed:
-    role: diagnostic
-    target_slot: subject
-    is_assisted: false
-    is_well_posed: false
-    use_for_main_forward: false
-    use_for_reverse_analysis: false
-    use_for_recognition_analysis: false
-    expected_queries: 1110
-    expected_facts: 1110
-    migrated_from: queryC_reverse(not well_posed)
-    description: >
-      Reverse queries whose inverse mapping is one-to-many ("What was developed
-      by Apple?"). Diagnostic only; never scored in any headline number.
-
-totals:
-  expected_total_queries: 44418
-  # anchor 2592 + paraphrase 10053 + format 7776 + context 6831 + multilingual 12010
-  expected_main_forward_queries: 39262
-  expected_benchmark_facts: 2592
-  expected_relations: 21
-
-# Spec 11: a query is a duplicate when fact_id + normalized text + target slot +
-# condition family all coincide.
-deduplication:
-  key: [fact_id, normalized_query, target_slot, condition_family]
-  expected_removed_during_migration: 10323
-
-# Deviations from the spec counts that have been investigated and written up in
-# outputs/reconstruction_differences.md. Listing one here stops the build from
-# failing on it; an UNLISTED deviation still fails, so a new regression cannot
-# hide behind a documented one.
-accepted_deviations:
-  - check: context.queries
-    actual: 6829
-    expected: 6831
-    ref: D1
-  - check: total_queries
-    actual: 44416
-    expected: 44418
-    ref: D1
-  - check: main_forward_queries
-    actual: 39260
-    expected: 39262
-    ref: D1

ICLR dataset/configs/models.yaml

@@ -1,178 +0,0 @@
-# Model registry. Spec section 4.4: the filtering models must live in
-# configuration rather than being hard-coded.
-#
-# The evaluated set follows Model/MODEL_SELECTION_20.md: 5 families x 4 models,
-# four size tiers, and four clean base<->instruct pairs spread across four
-# different families.
-#
-# revision: "local" means the snapshot under Model/ is authoritative. Record the
-# real commit hash once weights are re-pulled from the hub.
-
-model_root: /scratch/rds-fei-rsfm-rw/cshi0459/ICLR27/Model
-
-# ---- Stage I: five-model first-token candidate recall -----------------------
-# FROZEN. These five defined the 8,107-fact candidate pool that everything
-# downstream rests on. Changing this list invalidates
-# candidate_known_8107.jsonl and every artefact derived from it, so it must stay
-# fixed even as the evaluated set grows.
-filter_models:
-  - {name: Gemma-2-2B-it,   path: Gemma-2-2B-it,   revision: local}
-  - {name: Qwen2.5-7B,      path: Qwen2.5-7B,      revision: local}
-  - {name: Mistral-7B-v0.3, path: Mistral-7B-v0.3, revision: local}
-  - {name: Llama-3.1-8B,    path: Llama-3.1-8B,    revision: local}
-  - {name: Gemma-2-9B-it,   path: Gemma-2-9B-it,   revision: local}
-
-# ---- Stage V/VI: the 20 evaluated models ------------------------------------
-# Spec 7.1: qualification produces K_m LABELS only. Adding or removing a model
-# here never changes the benchmark denominator (fixed at 2,592), so this list is
-# safe to extend at any time without invalidating earlier results.
-#
-# n_layers / d_model / jlens_window come from MODEL_SELECTION_20.md, where
-# window = number of layers with normalized depth >= 0.4.
-evaluated_models:
-  # ---------------- Llama-3.x ----------------
-  - {name: Llama-3.2-1B,  path: Llama-3.2-1B,  hf: meta-llama/Llama-3.2-1B,
-     family: llama-3.x, tier: 1-5B, params_b: 1.24, tuning: base,
-     n_layers: 16, d_model: 2048, jlens_window: 10, revision: main}
-  - {name: Llama-3.2-3B,  path: Llama-3.2-3B,  hf: meta-llama/Llama-3.2-3B,
-     family: llama-3.x, tier: 1-5B, params_b: 3.21, tuning: base,
-     n_layers: 28, d_model: 3072, jlens_window: 17, revision: main}
-  - {name: Llama-3.1-8B,  path: Llama-3.1-8B,  hf: meta-llama/Llama-3.1-8B,
-     family: llama-3.x, tier: 5-9B, params_b: 8.03, tuning: base,
-     n_layers: 32, d_model: 4096, jlens_window: 19, revision: local,
-     pair: llama_8b}
-  - {name: Llama-3.1-8B-Instruct, path: Llama-3.1-8B-Instruct,
-     hf: meta-llama/Llama-3.1-8B-Instruct,
-     family: llama-3.x, tier: 5-9B, params_b: 8.03, tuning: instruct,
-     n_layers: 32, d_model: 4096, jlens_window: 19, revision: main,
-     pair: llama_8b}
-
-  # ---------------- Qwen2.5 ----------------
-  - {name: Qwen2.5-3B, path: Qwen2.5-3B, hf: Qwen/Qwen2.5-3B,
-     family: qwen2.5, tier: 1-5B, params_b: 3.09, tuning: base,
-     n_layers: 36, d_model: 2048, jlens_window: 22, revision: main}
-  - {name: Qwen2.5-7B, path: Qwen2.5-7B, hf: Qwen/Qwen2.5-7B,
-     family: qwen2.5, tier: 5-9B, params_b: 7.62, tuning: base,
-     n_layers: 28, d_model: 3584, jlens_window: 17, revision: local,
-     pair: qwen_7b}
-  - {name: Qwen2.5-7B-Instruct, path: Qwen2.5-7B-Instruct,
-     hf: Qwen/Qwen2.5-7B-Instruct,
-     family: qwen2.5, tier: 5-9B, params_b: 7.62, tuning: instruct,
-     n_layers: 28, d_model: 3584, jlens_window: 17, revision: main,
-     pair: qwen_7b}
-  - {name: Qwen2.5-32B, path: Qwen2.5-32B, hf: Qwen/Qwen2.5-32B,
-     family: qwen2.5, tier: 20B+, params_b: 32.76, tuning: base,
-     n_layers: 64, d_model: 5120, jlens_window: 38, revision: local}
-
-  # ---------------- Mistral ----------------
-  - {name: Mistral-7B-v0.3, path: Mistral-7B-v0.3, hf: mistralai/Mistral-7B-v0.3,
-     family: mistral, tier: 5-9B, params_b: 7.25, tuning: base,
-     n_layers: 32, d_model: 4096, jlens_window: 19, revision: local,
-     pair: mistral_7b}
-  - {name: Mistral-7B-Instruct-v0.3, path: Mistral-7B-Instruct-v0.3,
-     hf: mistralai/Mistral-7B-Instruct-v0.3,
-     family: mistral, tier: 5-9B, params_b: 7.25, tuning: instruct,
-     n_layers: 32, d_model: 4096, jlens_window: 19, revision: main,
-     pair: mistral_7b}
-  - {name: Mistral-Nemo-Base-2407, path: Mistral-Nemo-Base-2407,
-     hf: mistralai/Mistral-Nemo-Base-2407,
-     family: mistral, tier: 9-20B, params_b: 12.25, tuning: base,
-     n_layers: 40, d_model: 5120, jlens_window: 24, revision: main}
-  - {name: Mistral-Small-24B-Base-2501, path: Mistral-Small-24B-Base-2501,
-     hf: mistralai/Mistral-Small-24B-Base-2501,
-     family: mistral, tier: 20B+, params_b: 23.57, tuning: base,
-     n_layers: 40, d_model: 5120, jlens_window: 24, revision: main}
-
-  # ---------------- Gemma-2 ----------------
-  # Gemma-2 and OLMo-2 publish fp32 safetensors only; they are loaded with
-  # dtype=bfloat16, so on-disk size is ~2x the bf16 figure.
-  - {name: gemma-2-2b, path: gemma-2-2b, hf: google/gemma-2-2b,
-     family: gemma-2, tier: 1-5B, params_b: 2.61, tuning: base,
-     n_layers: 26, d_model: 2304, jlens_window: 16, revision: main}
-  - {name: gemma-2-9b, path: gemma-2-9b, hf: google/gemma-2-9b,
-     family: gemma-2, tier: 9-20B, params_b: 9.24, tuning: base,
-     n_layers: 42, d_model: 3584, jlens_window: 25, revision: main,
-     pair: gemma_9b}
-  - {name: Gemma-2-9B-it, path: Gemma-2-9B-it, hf: google/gemma-2-9b-it,
-     family: gemma-2, tier: 9-20B, params_b: 9.24, tuning: instruct,
-     n_layers: 42, d_model: 3584, jlens_window: 25, revision: local,
-     pair: gemma_9b}
-  - {name: gemma-2-27b, path: gemma-2-27b, hf: google/gemma-2-27b,
-     family: gemma-2, tier: 20B+, params_b: 27.23, tuning: base,
-     n_layers: 46, d_model: 4608, jlens_window: 28, revision: main}
-
-  # ---------------- OLMo-2 ----------------
-  # The only family with all four tiers AND fully public pretraining data, which
-  # is what makes "the model never saw this fact" separable from "the model
-  # cannot retrieve it".
-  - {name: OLMo-2-0425-1B, path: OLMo-2-0425-1B, hf: allenai/OLMo-2-0425-1B,
-     family: olmo-2, tier: 1-5B, params_b: 1.48, tuning: base,
-     n_layers: 16, d_model: 2048, jlens_window: 10, revision: main}
-  - {name: OLMo-2-1124-7B, path: OLMo-2-1124-7B, hf: allenai/OLMo-2-1124-7B,
-     family: olmo-2, tier: 5-9B, params_b: 7.30, tuning: base,
-     n_layers: 32, d_model: 4096, jlens_window: 19, revision: main}
-  - {name: OLMo-2-1124-13B, path: OLMo-2-1124-13B, hf: allenai/OLMo-2-1124-13B,
-     family: olmo-2, tier: 9-20B, params_b: 13.72, tuning: base,
-     n_layers: 40, d_model: 5120, jlens_window: 24, revision: main}
-  - {name: OLMo-2-0325-32B, path: OLMo-2-0325-32B, hf: allenai/OLMo-2-0325-32B,
-     family: olmo-2, tier: 20B+, params_b: 32.23, tuning: base,
-     n_layers: 64, d_model: 5120, jlens_window: 38, revision: main}
-
-# ---- base <-> instruct pairs (MODEL_SELECTION_20.md section 4) --------------
-# Same weights lineage, same tokenizer, same size; only post-training differs.
-# If BES improves while ISS does not, instruction tuning stabilised EXPRESSION
-# rather than KNOWLEDGE.
-tuning_pairs:
-  llama_8b:   {base: Llama-3.1-8B,     instruct: Llama-3.1-8B-Instruct,     family: llama-3.x, tier: 5-9B}
-  qwen_7b:    {base: Qwen2.5-7B,       instruct: Qwen2.5-7B-Instruct,       family: qwen2.5,   tier: 5-9B}
-  mistral_7b: {base: Mistral-7B-v0.3,  instruct: Mistral-7B-Instruct-v0.3,  family: mistral,   tier: 5-9B}
-  gemma_9b:   {base: gemma-2-9b,       instruct: Gemma-2-9B-it,             family: gemma-2,   tier: 9-20B}
-
-# ---- models that do NOT occupy an evaluated slot ----------------------------
-auxiliary_models:
-  stage_a_calibration:
-    name: Qwen2.5-0.5B
-    path: Qwen2.5-0.5B
-    hf: Qwen/Qwen2.5-0.5B
-    params_b: 0.49
-    n_layers: 24
-    d_model: 896
-    reason: exact full-matrix reference for J-Lens (J-Lens spec section 5)
-  judge:
-    name: Qwen2.5-32B-Instruct
-    path: Qwen2.5-32B-Instruct
-    hf: Qwen/Qwen2.5-32B-Instruct
-    params_b: 32.76
-    n_layers: 64
-    d_model: 5120
-    reason: semantic clustering judge (evaluation protocol section 3)
-    # Must be instruct (structured JSON output) and multilingual-strong: 12,010
-    # of 44,416 queries are zh/fr/es/de/ru.
-    known_bias: >
-      shares pretraining lineage with the four evaluated Qwen models and may
-      systematically favour their phrasing. Mitigation: agreement check against
-      src/scoring_full.py on a stratified sample, and optionally a second judge
-      (gemma-2-27b-it) on a subsample. The judge is never itself evaluated.
-
-# ---- excluded, with reasons (MODEL_SELECTION_20.md section 9) ---------------
-excluded_models:
-  - {name: Llama-3.1-70B, reason: "bf16 weights 141 GB vs 143 GB H200; quantisation would alter hidden states and break ISS/KTS comparability"}
-  - {name: Qwen2.5-14B,   reason: "could fill 9-20B but dropped to keep families balanced at 4 each; that tier still has 3 base models. Weights remain under Model/ but are not evaluated."}
-  - {name: Llama-2-13B,   reason: "different generation from Llama-3; mixing would break the family axis"}
-  - {name: Phi-3/Phi-4,   reason: "heavily synthetic training data; atypical knowledge profile"}
-  - {name: Yi/InternLM/GLM, reason: "adds family breadth but no new scientific axis"}
-
-# ---- Stage V/VI generation configuration (spec section 7.3) -----------------
-generation:
-  do_sample: false
-  num_beams: 1
-  temperature: 0.0
-  max_new_tokens: 24
-  max_prompt_len: 96
-  batch_size: 96
-  dtype: bfloat16
-  # Spec 7.2: identical raw prompt string for base and instruct models, so no
-  # chat template is ever applied. This matters more with 4 instruct models in
-  # the set: giving only those a chat template would confound tuning with format.
-  use_chat_template: false
-  seed: 20260101

ICLR dataset/configs/relations.yaml

@@ -1,256 +0,0 @@
-# Relation registry for the benchmark (spec sections 2.2, 5.4, 6.2).
-#
-# Per relation:
-#   relation_id      canonical snake_case name used in outputs
-#   source_relations Wikidata property ids (or source-native names) that map here
-#   direction        forward = subject + relation -> object, matching spec 2.2.
-#                    inverse = the source stores the pair the other way round.
-#   is_functional    the object is single- or approximately single-valued
-#   is_inverse_well_posed  object determines subject uniquely -> reverse queries
-#                    are meaningful; false means reverse goes to reverse_illposed
-#   answer_type / answer_granularity   drive scoring and reporting breakdowns
-#   qualification    canonical anchor question, slot {s}. Verified NOT to collide
-#                    with any evaluation perturbation template (spec 16).
-#   spec_6_2_flag    set when spec section 6.2 names this relation as unsuitable
-#                    while the required count of 2,592 needs it. See
-#                    outputs/reconstruction_differences.md.
-
-# Global switches ------------------------------------------------------------
-options:
-  # Spec 2.2 forbids mixing triple directions. P1376 ("X is the capital of Y")
-  # is stored inverse to P36. Flipping it merges those facts into `capital` and
-  # changes the benchmark size, which spec 10 forbids doing silently. Default
-  # false reproduces 2,592; set true only together with a差异 entry.
-  normalize_inverse_direction: false
-  # Spec 6.2 lists developer/manufacturer as unsuitable, but excluding them
-  # cannot reach the required 2,592. Default false keeps them and flags them.
-  drop_spec_6_2_flagged: false
-
-relations:
-  - relation_id: native_language
-    source_relations: [P103]
-    direction: forward
-    is_functional: true
-    is_inverse_well_posed: false
-    answer_type: language
-    answer_granularity: entity
-    qualification: "Which language did {s} grow up speaking?"
-
-  - relation_id: manufacturer
-    source_relations: [P176]
-    direction: forward
-    is_functional: true
-    is_inverse_well_posed: false
-    answer_type: organization
-    answer_granularity: entity
-    qualification: "Which company builds {s}?"
-    spec_6_2_flag: unsuitable_named_in_spec
-
-  - relation_id: developer
-    source_relations: [P178]
-    direction: forward
-    is_functional: true
-    is_inverse_well_posed: false
-    answer_type: organization
-    answer_granularity: entity
-    qualification: "Which company or person created {s}?"
-    spec_6_2_flag: unsuitable_named_in_spec
-
-  - relation_id: country
-    source_relations: [P17]
-    direction: forward
-    is_functional: true
-    is_inverse_well_posed: false
-    answer_type: country
-    answer_granularity: entity
-    qualification: "Which country does {s} belong to?"
-
-  - relation_id: original_network
-    source_relations: [P449]
-    direction: forward
-    is_functional: true
-    is_inverse_well_posed: false
-    answer_type: organization
-    answer_granularity: entity
-    qualification: "Which network first broadcast {s}?"
-
-  - relation_id: headquarters_location
-    source_relations: [P159]
-    direction: forward
-    is_functional: true
-    is_inverse_well_posed: false
-    answer_type: city
-    answer_granularity: entity
-    qualification: "Which city hosts the main offices of {s}?"
-
-  - relation_id: capital
-    source_relations: [P36]
-    direction: forward
-    is_functional: true
-    is_inverse_well_posed: true
-    answer_type: city
-    answer_granularity: entity
-    qualification: "Which city is the seat of government of {s}?"
-
-  - relation_id: capital_of
-    source_relations: [P1376]
-    direction: inverse          # stored as (city, capital_of, country)
-    inverse_of: capital
-    is_functional: true
-    is_inverse_well_posed: true
-    answer_type: country
-    answer_granularity: entity
-    qualification: "{s} is the capital city of which country?"
-
-  - relation_id: owned_by
-    source_relations: [P127]
-    direction: forward
-    is_functional: true
-    is_inverse_well_posed: false
-    answer_type: organization
-    answer_granularity: entity
-    qualification: "Who is the owner of {s}?"
-
-  - relation_id: sport
-    source_relations: [P641]
-    direction: forward
-    is_functional: true
-    is_inverse_well_posed: false
-    answer_type: sport
-    answer_granularity: entity
-    qualification: "Which sport is {s} associated with?"
-
-  - relation_id: continent
-    source_relations: [P30]
-    direction: forward
-    is_functional: true
-    is_inverse_well_posed: false
-    answer_type: place
-    answer_granularity: entity
-    qualification: "Which continent is {s} part of?"
-
-  - relation_id: religion
-    source_relations: [P140]
-    direction: forward
-    is_functional: true
-    is_inverse_well_posed: false
-    answer_type: religion
-    answer_granularity: entity
-    qualification: "Which faith does {s} follow?"
-
-  - relation_id: applies_to_jurisdiction
-    source_relations: [P1001]
-    direction: forward
-    is_functional: true
-    is_inverse_well_posed: false
-    answer_type: place
-    answer_granularity: entity
-    qualification: "Which jurisdiction does {s} have legal force in?"
-
-  - relation_id: location
-    source_relations: [P276]
-    direction: forward
-    is_functional: true
-    is_inverse_well_posed: false
-    answer_type: place
-    answer_granularity: entity
-    qualification: "At which location can {s} be found?"
-
-  - relation_id: country_of_origin
-    source_relations: [P495]
-    direction: forward
-    is_functional: true
-    is_inverse_well_posed: false
-    answer_type: country
-    answer_granularity: entity
-    qualification: "Which country did {s} originate from?"
-
-  - relation_id: place_of_death
-    source_relations: [P20]
-    direction: forward
-    is_functional: true
-    is_inverse_well_posed: false
-    answer_type: city
-    answer_granularity: entity
-    qualification: "At which place did {s} pass away?"
-
-  - relation_id: place_of_birth
-    source_relations: [P19]
-    direction: forward
-    is_functional: true
-    is_inverse_well_posed: false
-    answer_type: city
-    answer_granularity: entity
-    qualification: "In which place did {s} come into the world?"
-
-  - relation_id: located_in
-    source_relations: [P131]
-    direction: forward
-    is_functional: true
-    is_inverse_well_posed: false
-    answer_type: place
-    answer_granularity: entity
-    qualification: "Which administrative region contains {s}?"
-
-  - relation_id: position_played
-    source_relations: [P413]
-    direction: forward
-    is_functional: true
-    is_inverse_well_posed: false
-    answer_type: occupation
-    answer_granularity: entity
-    qualification: "On the field, which position is {s} assigned to?"
-
-  - relation_id: location_of_formation
-    source_relations: [P740]
-    direction: forward
-    is_functional: true
-    is_inverse_well_posed: false
-    answer_type: city
-    answer_granularity: entity
-    qualification: "{s} came into existence in which place?"
-
-  - relation_id: father
-    source_relations: [P22]
-    direction: forward
-    is_functional: true
-    is_inverse_well_posed: false
-    answer_type: person
-    answer_granularity: entity
-    qualification: "{s} is the child of which father?"
-
-# Relations present in the enriched pool but EXCLUDED from the benchmark because
-# the object is genuinely multi-valued, so an accepted-answer set can never be
-# exhaustive (spec 6.2). Kept here for auditability.
-excluded_multi_valued:
-  - {source_relations: [P37],   reason: official language}
-  - {source_relations: [P106],  reason: occupation}
-  - {source_relations: [P27],   reason: country of citizenship}
-  - {source_relations: [P31],   reason: instance of}
-  - {source_relations: [P279],  reason: subclass of}
-  - {source_relations: [P101],  reason: field of work}
-  - {source_relations: [P108],  reason: employer}
-  - {source_relations: [P463],  reason: member of}
-  - {source_relations: [P1303], reason: instrument}
-  - {source_relations: [P364],  reason: original language}
-  - {source_relations: [P407],  reason: language of work}
-  - {source_relations: [P1412], reason: language spoken}
-  - {source_relations: [P50, P57, P58, P86, P162], reason: creator roles}
-  - {source_relations: [P190],  reason: twinned city}
-  - {source_relations: [P47],   reason: shares border with}
-  - {source_relations: [P527],  reason: has part}
-  - {source_relations: [P264],  reason: record label}
-  - {source_relations: [P462],  reason: colour}
-  - {source_relations: [P937],  reason: work location}
-  - {source_relations: [P136],  reason: genre}
-  - {source_relations: [P25],   reason: mother}
-  - {source_relations: [IsA, UsedFor, AtLocation, HasA, HasProperty, CapableOf,
-                        PartOf, Causes, CausesDesire, Desires, NotDesires,
-                        HasSubevent, HasPrerequisite, MotivatedByGoal, MadeOf,
-                        ReceivesAction],
-     reason: ConceptNet open-world commonsense}
-
-# Relations excluded because they belong to non-core sources (spec 6.1)
-excluded_non_core:
-  - {source_relations: [date_of_birth, place_of_birth, place_of_death],
-     source: lama_googlere, reason: not a core source}

ICLR dataset/configs/source_templates.yaml

@@ -1,117 +0,0 @@
-# Raw source registry and Stage I cloze templates (spec sections 4.1 - 4.3).
-
-raw_root: /scratch/rds-fei-rsfm-rw/cshi0459/ICLR27/dataset
-
-sources:
-  counterfact:
-    path: counterfact/data/*.parquet
-    format: parquet
-    expected_triples: 21919
-    is_core: true
-    # spec 4.1: the TRUE object, never the counterfactual edit target
-    object_field: requested_rewrite.target_true.str
-    object_id_field: requested_rewrite.target_true.id
-    subject_field: requested_rewrite.subject
-    relation_field: requested_rewrite.relation_id
-    cloze: native            # the dataset ships its own prompt template
-
-  lama_trex:
-    path: lama/data/TREx/*.jsonl
-    format: jsonl
-    expected_triples: 34039
-    is_core: true
-    subject_field: sub_label
-    subject_id_field: sub_uri
-    relation_field: predicate_id
-    object_field: obj_label
-    object_id_field: obj_uri
-    cloze: relations_jsonl_template     # lama/data/relations.jsonl, cut at [Y]
-
-  lama_googlere:
-    path: lama/data/Google_RE/*.jsonl
-    format: jsonl
-    expected_triples: 5528
-    is_core: false
-    subject_field: sub_label
-    relation_field: pred            # last path segment
-    object_field: obj_label
-    alias_fields: [sub_aliases, obj_aliases]
-    cloze: handwritten
-    templates:
-      place_of_birth: "{s} was born in"
-      place_of_death: "{s} died in"
-      date_of_birth: "{s} was born in the year"
-
-  lama_conceptnet:
-    path: lama/data/ConceptNet/*.jsonl
-    format: jsonl
-    expected_triples: 28914
-    is_core: false
-    subject_field: sub_label
-    relation_field: pred
-    object_field: obj_label
-    cloze: masked_sentence          # masked_sentences[0], cut at [MASK]
-
-  t_rex:
-    path: trex/*.jsonl
-    format: jsonl
-    expected_triples: 1592952
-    is_core: false
-    subject_field: head
-    relation_field: relation        # natural-language template with brackets
-    object_field: tail
-    cloze: bracket_template
-    # spec 4.5: dropped after consensus filtering (pass rate 0.17%)
-    drop_after_consensus: true
-
-  wikidata5m:
-    path: wikidata5m/extracted/wikidata5m_all_triplet.txt
-    format: tsv
-    expected_triples: 21354359
-    is_core: false
-    cloze: generic                  # "{subject} {relation}"
-    # spec 4.3: strided down to ~100k prompts before model filtering
-    sample:
-      method: stride
-      target_prompts: 100000
-      actual_prompts: 100189
-    drop_after_consensus: true
-
-  popqa:
-    path: hf_cache/hub/datasets--akariasai--PopQA/snapshots/*/test.tsv
-    format: tsv
-    is_core: true
-    # spec 4.1 / 4.5: added AFTER the initial consensus stage, then run through
-    # the identical five-model first-token protocol
-    added_after_consensus: true
-    expected_prompts: 14149
-    expected_passed: 378
-    alias_fields: [s_aliases, o_aliases, possible_answers]
-
-# Aggregate expectations (spec section 1)
-expected:
-  raw_triples_total: 23038571
-  cloze_prompts: 1783541
-  five_model_consensus: 10601
-  candidate_known: 8107
-
-alias_resources:
-  wikidata_entity_aliases: wikidata5m/extracted/wikidata5m_alias/wikidata5m_entity.txt
-  # spec 5.3: scan once, keep only the QIDs the candidate set needs
-  scan_mode: filtered_single_pass
-  max_aliases_per_entity: 16
-  # crowd-sourced alias lists carry Wikipedia housekeeping titles and ISO codes
-  junk_patterns:
-    - "^list of "
-    - "^books?/"
-    - "^number of "
-    - "^category:"
-    - "^template:"
-    - "^wikipedia:"
-    - "^iso \\d"
-    - "^portal:"
-    - "^index of "
-    - "^outline of "
-    - "\\(disambiguation\\)"
-    - "/"
-  min_alias_chars: 2

ICLR dataset/evaluation_queries_44416.jsonl

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:0e50fdc64b962a1f4a532f7b72e62a04f67d363ba80e58f000f4985dcdb1f1c8
-size 41495062

ICLR dataset/metrics/bcs_bes.py

@@ -1,161 +0,0 @@
-#!/usr/bin/env python
-"""BCS and BES from the judge's semantic clusters.   (protocol 4, 5, 6)
-
-    python src/bcs_bes.py --model Llama-3.2-1B
-
-Family-balanced, per protocol 4.1: the distribution over answer clusters is
-computed WITHIN each condition family first, then the families are averaged with
-equal weight. Counting raw queries instead would let paraphrase (10,053) and
-multilingual (12,010) drown out anchor (2,592), and the headline number would
-mostly measure how many variants we happened to write.
-
-    p(a) = mean over families of  (share of that family's queries in cluster a)
-    BCS  = max_a p(a)
-    BES  = 1 - H(p)/log A      (1 when only one cluster was observed)
-
-BCS deliberately does not consult correctness: a model that answers "Sydney" for
-every phrasing of Australia's capital scores BCS = 1. That is the point --
-protocol 6 then splits stable behaviour into Stable Correct and Stable Wrong
-using the judge's reference-aware pass.
-"""
-import os, sys, math, argparse, collections
-
-import numpy as np
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-import mcommon as mc
-
-
-def bcs_bes(assignments, families):
-    """assignments: [(condition_family, cluster_id)] for one fact."""
-    counts = collections.defaultdict(collections.Counter)
-    for fam, cid in assignments:
-        counts[fam][cid] += 1
-    valid = [t for t in families if counts[t]]
-    if not valid:
-        return None
-    clusters = {c for t in valid for c in counts[t]}
-    p = {c: sum(counts[t][c] / sum(counts[t].values()) for t in valid) / len(valid)
-         for c in clusters}
-    modal = max(p, key=p.get)
-    pos = [v for v in p.values() if v > 0]
-    if len(pos) == 1:
-        bes = 1.0
-    else:
-        H = -sum(v * math.log(v) for v in pos)
-        bes = 1.0 - H / math.log(len(pos))
-    return {"bcs": p[modal], "bes": bes, "modal_cluster": modal,
-            "cluster_distribution": p, "valid_families": valid}
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--model", required=True)
-    ap.add_argument("--coverage", choices=["complete_family", "full_set"], default=None)
-    ap.add_argument("--sample", type=int, default=0,
-                    help="score only the same fixed subset judge_run.py sampled")
-    ap.add_argument("--sample-seed", type=int, default=20260101)
-    args = ap.parse_args()
-
-    C = mc.cfg()
-    mode = args.coverage or C["headline_coverage"]
-    fams = C["main_families"]
-    tau = C["behavior"]["tau_b"]
-    keep = set(mc.eval_fact_set(mode))
-    if args.sample:
-        # Reproduce judge_run.py's draw exactly. A judge file can hold extra
-        # facts -- a debug run, or a --resume over an earlier partial pass --
-        # and scoring whatever happens to be in the file would give different
-        # models different fact sets, which protocol 1.3 forbids.
-        allf = sorted(mc.facts())
-        rng = np.random.default_rng(args.sample_seed)
-        pick = set(np.array(allf)[rng.choice(len(allf), size=args.sample,
-                                             replace=False)].tolist())
-        keep &= pick
-    rel_of = mc.fact_relation()
-
-    jpath = mc.out("metrics", "judge", f"{args.model}.jsonl")
-    if not os.path.exists(jpath):
-        raise SystemExit(f"no judge output for {args.model}; run src/judge_run.py")
-
-    per_fact, groups = [], collections.Counter()
-    for rec in mc.read_jsonl(jpath):
-        fid = rec["fact_id"]
-        if fid not in keep:
-            continue
-        label = {c["cluster_id"]: c for c in rec["clusters"]}
-        res = bcs_bes([(a["condition_family"], a["cluster_id"])
-                       for a in rec["assignments"]], fams)
-        if res is None:
-            continue
-        modal = label.get(res["modal_cluster"], {})
-        correctness = modal.get("correctness", "REVIEW_REQUIRED")
-        status = modal.get("status", "ANSWER")
-        # Protocol 6: the four behaviour groups partition the fact set, so every
-        # fact lands in exactly one and the four rates sum to 1.
-        if res["bcs"] < tau:
-            grp = "Unstable"
-        elif status == "ABSTAIN" or correctness == "ABSTAIN":
-            grp = "Stable Abstention"
-        elif correctness == "CORRECT":
-            grp = "Stable Correct"
-        elif correctness == "INCORRECT":
-            grp = "Stable Wrong"
-        else:
-            grp = "Stable Unresolved"
-        groups[grp] += 1
-        per_fact.append({"model": args.model, "fact_id": fid, "relation": rel_of[fid],
-                         "bcs": res["bcs"], "bes": res["bes"],
-                         "modal_cluster": res["modal_cluster"],
-                         "modal_correctness": correctness, "behavior_group": grp,
-                         "valid_families": res["valid_families"]})
-
-    if not per_fact:
-        raise SystemExit(f"{args.model}: no facts scored")
-    mc.write_jsonl(mc.out("metrics", "behavioral", f"{args.model}.{mode}.per_fact.jsonl"),
-                   per_fact)
-
-    n = len(per_fact)
-    bs = C["bootstrap"]
-    boot_bcs = mc.relation_clustered_bootstrap(
-        {r["fact_id"]: r["bcs"] for r in per_fact}, rel_of,
-        bs["n_resamples"], bs["seed"], bs["ci"])
-    boot_bes = mc.relation_clustered_bootstrap(
-        {r["fact_id"]: r["bes"] for r in per_fact}, rel_of,
-        bs["n_resamples"], bs["seed"], bs["ci"])
-
-    # Protocol 6: threshold sensitivity, because tau_b = 0.8 is a choice.
-    sens = {}
-    for t in C["behavior"]["tau_sensitivity"]:
-        sens[str(t)] = {"stable_rate": float(np.mean([r["bcs"] >= t for r in per_fact])),
-                        "stable_correct": float(np.mean(
-                            [r["bcs"] >= t and r["modal_correctness"] == "CORRECT"
-                             for r in per_fact]))}
-
-    summary = {
-        "model": args.model, "coverage_mode": mode, "n_facts": n, "tau_b": tau,
-        "bcs": boot_bcs["mean"], "bcs_ci95": [boot_bcs["lo"], boot_bcs["hi"]],
-        "bes": boot_bes["mean"], "bes_ci95": [boot_bes["lo"], boot_bes["hi"]],
-        "stable_correct_rate": groups["Stable Correct"] / n,
-        "stable_wrong_rate": groups["Stable Wrong"] / n,
-        "stable_abstention_rate": groups["Stable Abstention"] / n,
-        "stable_unresolved_rate": groups["Stable Unresolved"] / n,
-        "unstable_rate": groups["Unstable"] / n,
-        "behavior_counts": dict(groups),
-        "tau_sensitivity": sens,
-    }
-    tot = sum(summary[k] for k in ("stable_correct_rate", "stable_wrong_rate",
-                                   "stable_abstention_rate", "stable_unresolved_rate",
-                                   "unstable_rate"))
-    if abs(tot - 1.0) > 1e-6:
-        raise SystemExit(f"behaviour rates sum to {tot}, not 1 (protocol 6)")
-    mc.write_json(mc.out("metrics", "behavioral", f"{args.model}.{mode}.summary.json"),
-                  summary)
-    print(f"[{args.model}] BCS={summary['bcs']:.4f} BES={summary['bes']:.4f} "
-          f"SC={summary['stable_correct_rate']:.3f} SW={summary['stable_wrong_rate']:.3f} "
-          f"SA={summary['stable_abstention_rate']:.3f} "
-          f"U={summary['unstable_rate']:.3f}  n={n}  BCSBES_DONE")
-
-
-if __name__ == "__main__":
-    main()

ICLR dataset/metrics/extract_hidden.py

@@ -1,171 +0,0 @@
-#!/usr/bin/env python
-"""Query-end residual states for the main-forward queries.   [GPU]
-
-    python src/extract_hidden.py --model Llama-3.2-1B
-
-Protocol 2.4 fixes the probe position:
-
-    the last valid input token -- the model has read the question but has not
-    yet emitted an answer token
-
-which is exactly the prefill position that produces the first generated token
-in eval_run.py. The prompt string is therefore built by importing eval_run's own
-`build_prompt`, not by re-deriving it here: if the two ever diverged, ISS would
-be measured on a different question than BCS/BES, and nothing downstream would
-notice.
-
-Only decoder blocks inside the J-Lens analysis window (protocol 7.10,
-d_l = l/(L-1) >= 0.4) are stored. Layer `l` is the OUTPUT of block l, so the
-last stored layer, l = L-1, is the final residual stream that J-Lens transports
-into.
-
-Output, per model:
-
-    outputs/hidden/<model>/L###.npy    float16 [n_queries, d]
-    outputs/hidden/<model>/index.json  query order + layer list + checksums
-"""
-import os, sys, json, time, argparse, hashlib
-
-import numpy as np
-import torch
-from transformers import AutoModelForCausalLM, AutoTokenizer
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-import mcommon as mc
-
-# eval_run.py owns the prompt format; import it so there is exactly one copy.
-sys.path.insert(0, mc.ds3("src"))
-from eval_run import build_prompt          # noqa: E402
-
-
-def decoder_layers(model):
-    """The block list, across Llama / Qwen2 / Mistral / Gemma2 / OLMo2."""
-    for attr in ("model.layers", "model.decoder.layers", "transformer.h"):
-        obj = model
-        try:
-            for part in attr.split("."):
-                obj = getattr(obj, part)
-            if isinstance(obj, torch.nn.ModuleList) and len(obj):
-                return obj
-        except AttributeError:
-            continue
-    raise SystemExit(f"cannot locate decoder blocks on {type(model).__name__}")
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--model", required=True)
-    ap.add_argument("--batch", type=int, default=0)
-    ap.add_argument("--limit", type=int, default=0, help="debug: first N queries")
-    ap.add_argument("--force", action="store_true")
-    args = ap.parse_args()
-
-    conf = mc.cfg()["extraction"]
-    entry = mc.model_entry(args.model)
-    dest = mc.out("hidden", args.model)
-    os.makedirs(dest, exist_ok=True)
-    index_path = os.path.join(dest, "index.json")
-    if os.path.exists(index_path) and not args.force:
-        if json.load(open(index_path)).get("complete"):
-            print(f"[{args.model}] already extracted; --force to redo")
-            return
-
-    rows = mc.main_forward_queries()
-    if args.limit:
-        rows = rows[:args.limit]
-    N = len(rows)
-
-    path = mc.model_path(args.model)
-    tok = AutoTokenizer.from_pretrained(path)
-    if tok.pad_token is None:
-        tok.pad_token = tok.eos_token
-    # Left padding is what makes position -1 the last REAL token for every row
-    # in a ragged batch; with right padding it would be a pad token.
-    tok.padding_side = "left"
-    tok.truncation_side = "left"
-    model = AutoModelForCausalLM.from_pretrained(
-        path, dtype=torch.bfloat16, device_map={"": 0}).eval()
-
-    blocks = decoder_layers(model)
-    L = len(blocks)
-    if L != entry.get("n_layers", L):
-        raise SystemExit(f"{args.model}: config.json has {L} layers but "
-                         f"models.yaml says {entry['n_layers']}")
-    d = int(model.config.hidden_size)
-    window = mc.layer_window(L)
-    if len(window) != entry.get("jlens_window", len(window)):
-        raise SystemExit(f"{args.model}: computed window {len(window)} layers "
-                         f"but models.yaml says {entry['jlens_window']}")
-    print(f"[{args.model}] L={L} d={d} window={window[0]}..{window[-1]} "
-          f"({len(window)} layers)  N={N}", flush=True)
-
-    stores = {l: np.lib.format.open_memmap(
-        os.path.join(dest, f"L{l:03d}.npy"), mode="w+",
-        dtype=np.float16, shape=(N, d)) for l in window}
-
-    grabbed = {}
-
-    def make_hook(l):
-        def hook(_module, _inp, output):
-            h = output[0] if isinstance(output, tuple) else output
-            # Detach immediately and keep only the probe position, otherwise the
-            # full [B, T, d] activation for every window layer stays alive.
-            grabbed[l] = h[:, -1, :].detach().float()
-        return hook
-
-    handles = [blocks[l].register_forward_hook(make_hook(l)) for l in window]
-
-    prompts = [build_prompt(r) for r in rows]
-    B = args.batch or conf["batch_size"]
-    max_len = conf["max_prompt_len"]
-    # Length-sorted batching keeps padding low; `order` maps back to row index.
-    order = sorted(range(N), key=lambda i: len(prompts[i]))
-    t0 = time.time()
-    with torch.no_grad():
-        for b in range(0, N, B):
-            idx = order[b:b + B]
-            enc = tok([prompts[i] for i in idx], return_tensors="pt", padding=True,
-                      truncation=True, max_length=max_len).to(0)
-            grabbed.clear()
-            model(**enc, use_cache=False)
-            for l in window:
-                stores[l][idx] = grabbed[l].to(torch.float16).cpu().numpy()
-            if b % (B * 40) == 0:
-                done = b + len(idx)
-                print(f"  {done}/{N}  {done / max(time.time() - t0, 1e-9):.1f}/s",
-                      flush=True)
-    for h in handles:
-        h.remove()
-    for l in window:
-        stores[l].flush()
-
-    meta = {
-        "model": args.model,
-        "complete": True,
-        "n_queries": N,
-        "n_layers": L,
-        "d_model": d,
-        "window": window,
-        "window_depths": [round(l / max(L - 1, 1), 4) for l in window],
-        "late_window": mc.late_window(L),
-        "position": conf["position"],
-        "dtype": "float16",
-        "max_prompt_len": max_len,
-        "batch_size": B,
-        "seconds": round(time.time() - t0, 1),
-        # The query order is the contract between this file and every consumer;
-        # the hash lets a consumer prove it is reading the same ordering.
-        "query_ids": [r["query_id"] for r in rows],
-        "fact_ids": [r["fact_id"] for r in rows],
-        "families": [r["condition_family"] for r in rows],
-        "query_order_sha256": hashlib.sha256(
-            "\n".join(r["query_id"] for r in rows).encode()).hexdigest(),
-    }
-    mc.write_json(index_path, meta)
-    gb = N * len(window) * d * 2 / 1e9
-    print(f"[{args.model}] wrote {len(window)} layers x {N} x {d}  "
-          f"({gb:.1f} GB)  {meta['seconds']}s  EXTRACT_DONE", flush=True)
-
-
-if __name__ == "__main__":
-    main()

ICLR dataset/metrics/iss.py

@@ -1,157 +0,0 @@
-#!/usr/bin/env python
-"""ISS: Internal State Stability.   (protocol 7, J-Lens spec 10)
-
-    python src/iss.py --model Llama-3.2-1B --transport raw     # ablation
-    python src/iss.py --model Llama-3.2-1B --transport jlens   # official
-
-The state preparation (transport -> residualise -> whiten -> family centroid)
-lives in states.py so that ISS and KTS provably score the same vectors. What is
-here is only the ISS-specific part:
-
-    S+  same fact, across condition-family pairs
-    S-  same relation, different fact, symmetric in the family pair
-    ISS = (S+ - S-) / (1 - S- + eps)
-
-Raw-ISS is NOT the official metric (J-Lens spec 11). It exists to prove the
-data loading, family aggregation and negative sampling are right before the
-Jacobian transport is layered on top (spec 21, step 1).
-"""
-import os, sys, time, argparse
-
-import numpy as np
-import torch
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-import mcommon as mc
-from states import StateLoader
-
-
-def iss_one_layer(V, mask, by_rel, negatives, eps):
-    """S+, S- and ISS for every fact at one layer."""
-    F, T, _ = V.shape
-    dev = V.device
-    s_pos = torch.zeros(F, device=dev)
-    s_neg = torch.zeros(F, device=dev)
-    n_pos = torch.zeros(F, device=dev)
-    n_neg = torch.zeros(F, device=dev)
-    zero = torch.zeros(F, device=dev)
-
-    for t in range(T):
-        for u in range(t + 1, T):
-            both = mask[:, t] & mask[:, u]
-            if not bool(both.any()):
-                continue
-            s_pos += torch.where(both, (V[:, t] * V[:, u]).sum(-1), zero)
-            n_pos += both.float()
-
-            # Protocol 7.8: same-relation background, symmetrised over the pair
-            # so a family that sits globally closer to everything cannot inflate
-            # the score. Done per relation to keep each similarity block small.
-            for members in by_rel.values():
-                idx = [i for i in members if bool(both[i])]
-                if len(idx) < 2:
-                    continue
-                ii = torch.tensor(idx, device=dev)
-                Sab = V[ii, t] @ V[ii, u].T
-                pos = {f: j for j, f in enumerate(idx)}
-                for f in idx:
-                    negs = [pos[g] for g in negatives[f] if g in pos]
-                    if not negs:
-                        continue
-                    jj = torch.tensor(negs, device=dev)
-                    j0 = pos[f]
-                    s_neg[f] += 0.5 * (Sab[j0, jj].mean() + Sab[jj, j0].mean())
-                    n_neg[f] += 1
-
-    sp = s_pos / n_pos.clamp_min(1)
-    sn = s_neg / n_neg.clamp_min(1)
-    return sp, sn, (sp - sn) / (1.0 - sn + eps), (n_pos > 0) & (n_neg > 0)
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--model", required=True)
-    ap.add_argument("--transport", choices=["raw", "jlens"], default="raw")
-    ap.add_argument("--coverage", choices=["complete_family", "full_set"], default=None)
-    ap.add_argument("--device", default="auto")
-    ap.add_argument("--shuffle-seed", type=int, default=None,
-                    help="protocol 18.1 control: destroy fact identity; ISS must collapse")
-    args = ap.parse_args()
-
-    C = mc.cfg()
-    icfg = C["iss"]
-    eps = float(icfg["eps"])
-    S = StateLoader(args.model, args.transport, args.coverage, args.device,
-                    shuffle_seed=args.shuffle_seed)
-
-    negatives = mc.negative_sample(S.keep_facts, S.rel_of,
-                                   icfg["max_negatives"], icfg["negative_seed"])
-    negatives = {S.fidx[f]: [S.fidx[g] for g in gs] for f, gs in negatives.items()}
-
-    F = S.n_facts
-    per_layer, t0 = {}, time.time()
-    for l in S.window:
-        V, mask = S.centroids(l)
-        sp, sn, iss, valid = iss_one_layer(V, mask, S.by_rel, negatives, eps)
-        per_layer[l] = {"s_pos": sp.cpu().numpy(), "s_neg": sn.cpu().numpy(),
-                        "iss": iss.cpu().numpy(), "valid": valid.cpu().numpy()}
-        print(f"  L{l:03d}  ISS={float(iss[valid].mean()):+.4f}  "
-              f"S+={float(sp[valid].mean()):.4f}  S-={float(sn[valid].mean()):.4f}",
-              flush=True)
-        del V, mask
-        if S.dev == "cuda":
-            torch.cuda.empty_cache()
-
-    # ---- protocol 7.10: window mean, peak, late
-    stack = np.stack([per_layer[l]["iss"] for l in S.window])
-    vmask = np.stack([per_layer[l]["valid"] for l in S.window])
-    stack = np.where(vmask, stack, np.nan)
-    late_rows = [i for i, l in enumerate(S.window) if l in S.late]
-    with np.errstate(invalid="ignore"):
-        iss_f = np.nanmean(stack, axis=0)
-        peak_f = np.nanmax(stack, axis=0)
-        late_f = np.nanmean(stack[late_rows], axis=0) if late_rows else np.full(F, np.nan)
-
-    rows = [{"model": args.model, "transport": args.transport, "fact_id": f,
-             "relation": S.rel_of[f], "iss": float(iss_f[i]),
-             "iss_peak": float(peak_f[i]), "iss_late": float(late_f[i]),
-             "layers_used": S.window}
-            for i, f in enumerate(S.keep_facts) if np.isfinite(iss_f[i])]
-
-    tag = f"{args.model}.{args.transport}.{S.mode}"
-    if args.shuffle_seed is not None:
-        tag += f".shuffled{args.shuffle_seed}"
-    mc.write_jsonl(mc.out("metrics", "iss", f"{tag}.per_fact.jsonl"), rows)
-    mc.write_jsonl(mc.out("metrics", "iss", f"{tag}.per_fact_layer.jsonl"),
-                   [{"model": args.model, "transport": args.transport,
-                     "fact_id": f, "layer": l,
-                     "iss": float(per_layer[l]["iss"][i]),
-                     "s_positive": float(per_layer[l]["s_pos"][i]),
-                     "s_background": float(per_layer[l]["s_neg"][i])}
-                    for l in S.window for i, f in enumerate(S.keep_facts)
-                    if per_layer[l]["valid"][i]])
-
-    vals = {r["fact_id"]: r["iss"] for r in rows}
-    boot = mc.relation_clustered_bootstrap(
-        vals, S.rel_of, C["bootstrap"]["n_resamples"], C["bootstrap"]["seed"],
-        C["bootstrap"]["ci"])
-    summary = {
-        "model": args.model, "transport": args.transport, "coverage_mode": S.mode,
-        "official": args.transport == "jlens" and args.shuffle_seed is None,
-        "shuffle_control": args.shuffle_seed is not None,
-        "n_facts": len(rows), "layers": S.window,
-        "iss": boot["mean"], "iss_ci95": [boot["lo"], boot["hi"]],
-        "iss_peak": float(np.nanmean(peak_f)), "iss_late": float(np.nanmean(late_f)),
-        "s_positive": float(np.nanmean([per_layer[l]["s_pos"] for l in S.window])),
-        "s_background": float(np.nanmean([per_layer[l]["s_neg"] for l in S.window])),
-        "per_layer_iss": {str(l): float(np.nanmean(np.where(
-            per_layer[l]["valid"], per_layer[l]["iss"], np.nan))) for l in S.window},
-        "seconds": round(time.time() - t0, 1),
-    }
-    mc.write_json(mc.out("metrics", "iss", f"{tag}.summary.json"), summary)
-    print(f"[{args.model}] {args.transport}-ISS = {boot['mean']:+.4f} "
-          f"[{boot['lo']:+.4f},{boot['hi']:+.4f}]  n={len(rows)}  ISS_DONE", flush=True)
-
-
-if __name__ == "__main__":
-    main()

ICLR dataset/metrics/jlens.py

@@ -1,352 +0,0 @@
-#!/usr/bin/env python
-"""J-Lens: randomized factorized estimate of the layer-to-final Jacobian.  [GPU]
-
-    python src/jlens.py --model Llama-3.2-1B --rank 256
-    python src/jlens.py --model Llama-3.2-1B --validate      # spec 7.1 action check
-
-Official transport (J-Lens spec 1):
-
-    z^l = J^l h^l,    J^l = E_{x~C}[ d h^L(x) / d h^l(x) ]
-
-with NO unembedding matrix -- the metric lives in the final-layer residual
-basis, not in vocabulary space.
-
-d x d is unaffordable at d = 5120, so spec 6 prescribes randomized range
-finding:
-
-    Y = J Omega   (JVPs)        Q = qr(Y)
-    B = Q^T J     (VJPs)        Jhat = Q B
-
-and spec 6.4 says to store only Q and B. Downstream we only ever take cosines,
-and Q is orthonormal, so cos(Q y1, Q y2) = cos(y1, y2) -- iss.py consumes
-y = B h directly in r dimensions.
-
---- how the per-example Jacobian is taken -------------------------------------
-
-J_x is the Jacobian of the map
-
-    h^l at the last position  ->  h^L at the last position
-
-holding the prefix fixed. Attention is causal, so perturbing the last position's
-residual cannot change any earlier position: the prefix KV cache computed once
-is exactly right, and the map can be evaluated by a single-token decode step
-with a hook that substitutes h at block l. That costs one token through the
-blocks instead of a full re-prefill, and it goes through the stock HF decode
-path, so it stays correct for Llama / Qwen2 / Mistral / Gemma2 (sliding window,
-logit softcap) / OLMo2 alike without per-architecture code.
-
-Tangents are batched along the batch dimension: the map is block-diagonal across
-batch rows, so one jvp call returns J_x v_i for as many probe columns as fit.
-"""
-import os, sys, json, time, argparse, copy
-
-import numpy as np
-import torch
-from transformers import AutoModelForCausalLM, AutoTokenizer
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-import mcommon as mc
-from extract_hidden import decoder_layers
-
-
-# --------------------------------------------------------------- calibration
-def calibration_prompts(tok, n, seq_len, seed):
-    """Spec 13.1: general text, independent of the factual benchmark.
-
-    Every model sees the same document slice and the same token count, so the
-    corpus contributes no cross-model variation (spec 8.1: "same construction
-    rule for all models").
-    """
-    from datasets import load_dataset
-    ds = load_dataset("NeelNanda/pile-10k", split="train")
-    rng = np.random.default_rng(seed)
-    picks = rng.choice(len(ds), size=min(4 * n, len(ds)), replace=False)
-    out, used = [], []
-    for i in picks:
-        ids = tok(ds[int(i)]["text"], return_tensors="pt",
-                  truncation=True, max_length=seq_len)["input_ids"][0]
-        if ids.numel() < seq_len:
-            continue                       # fixed length only (spec 8.1)
-        out.append(ids[:seq_len])
-        used.append(int(i))
-        if len(out) == n:
-            break
-    if len(out) < n:
-        raise SystemExit(f"only {len(out)}/{n} calibration prompts reached {seq_len} tokens")
-    return torch.stack(out), used
-
-
-FP32_BUDGET_GB = 110.0     # of the 143 GB H200, leaving room for activations
-
-
-def pick_dtype(name, requested="auto"):
-    """float32 wherever the weights fit, bfloat16 only when they cannot.
-
-    Measured on Qwen2.5-0.5B, a bf16 JVP agrees with the fp32 one to
-    cos >= 0.996 but with 1-8% relative error, worst at early layers -- above
-    the 0.05 action-error threshold the J-Lens spec (7.3) sets for accepting an
-    estimator. Corpus averaging suppresses most of that, but it is cheaper to
-    avoid the noise than to argue about it, so fp32 is the default and the
-    fallback is recorded in metadata for the uncertainty report (spec 18).
-    """
-    if requested != "auto":
-        return getattr(torch, requested)
-    params_b = float(mc.model_entry(name).get("params_b", 0) or 0)
-    return torch.float32 if params_b * 4.0 < FP32_BUDGET_GB else torch.bfloat16
-
-
-def load_for_jacobian(name, dtype="auto"):
-    """Eager attention is mandatory here.
-
-    The fused SDPA/flash kernels have no double-backward rule, and the JVP below
-    is reverse-over-reverse. Eager attention is slower but it is the only
-    implementation that differentiates twice. Generation and hidden-state
-    extraction are unaffected -- they never take a second derivative.
-    """
-    dt = pick_dtype(name, dtype)
-    path = mc.model_path(name)
-    tok = AutoTokenizer.from_pretrained(path)
-    model = AutoModelForCausalLM.from_pretrained(
-        path, dtype=dt, device_map={"": 0}, attn_implementation="eager").eval()
-    for prm in model.parameters():
-        prm.requires_grad_(False)
-    return model, tok
-
-
-def _cache_tensors(cache):
-    """The K/V tensor slots of a Cache, across the layouts transformers uses."""
-    slots = []
-    if getattr(cache, "layers", None):
-        for lay in cache.layers:
-            for attr in ("keys", "values"):
-                if getattr(lay, attr, None) is not None:
-                    slots.append((lay, attr))
-    for attr in ("key_cache", "value_cache"):
-        seq = getattr(cache, attr, None)
-        if seq is not None:
-            for i in range(len(seq)):
-                slots.append((seq, i))
-    return slots
-
-
-def _expand_cache(cache, b):
-    """Replicate a batch-1 prefix cache to batch b without re-running the prefix."""
-    c = copy.deepcopy(cache)
-    for holder, key in _cache_tensors(c):
-        t = holder[key] if isinstance(key, int) else getattr(holder, key)
-        t = t.expand(b, *t.shape[1:]).contiguous()
-        if isinstance(key, int):
-            holder[key] = t
-        else:
-            setattr(holder, key, t)
-    return c
-
-
-class TailMap:
-    """h^l(last position) -> h^L(last position), prefix held fixed.
-
-    Causal attention is what makes this well defined: the last position cannot
-    influence earlier ones, so the prefix KV computed once is exactly correct
-    however h^l is perturbed.
-    """
-
-    def __init__(self, model, blocks, layer, ids):
-        self.model, self.blocks, self.layer = model, blocks, layer
-        self.n_layers = len(blocks)
-        self.sub = None          # tensor substituted at block `layer`
-        self.final = None
-        with torch.no_grad():
-            pre = model(input_ids=ids[:, :-1].to(model.device), use_cache=True)
-        self.prefix = pre.past_key_values
-        self.last = ids[:, -1:].to(model.device)
-        self._install()
-
-    def _install(self):
-        def sub_hook(_m, _i, output):
-            if self.sub is None:
-                return output
-            tup = isinstance(output, tuple)
-            h = output[0] if tup else output
-            # Rebuild rather than index-assign: the substituted row carries the
-            # autograd graph and an in-place write into a non-leaf bf16 buffer
-            # is both fragile and unnecessary here (sequence length is 1).
-            h = self.sub.to(h.dtype).unsqueeze(1)
-            return (h,) + tuple(output[1:]) if tup else h
-
-        def grab_hook(_m, _i, output):
-            h = output[0] if isinstance(output, tuple) else output
-            self.final = h[:, -1, :]
-
-        self.h1 = self.blocks[self.layer].register_forward_hook(sub_hook)
-        self.h2 = self.blocks[self.n_layers - 1].register_forward_hook(grab_hook)
-
-    def close(self):
-        self.h1.remove()
-        self.h2.remove()
-
-    def baseline(self):
-        """h^l at the last position, unperturbed -- the expansion point."""
-        got = {}
-
-        def hook(_m, _i, output):
-            h = output[0] if isinstance(output, tuple) else output
-            got["h"] = h[:, -1, :].detach().clone()
-        hd = self.blocks[self.layer].register_forward_hook(hook)
-        self.sub = None
-        with torch.no_grad():
-            self._decode(1)
-        hd.remove()
-        return got["h"]
-
-    def _decode(self, batch):
-        cache = _expand_cache(self.prefix, batch) if batch > 1 \
-            else copy.deepcopy(self.prefix)
-        self.model(input_ids=self.last.expand(batch, 1),
-                   past_key_values=cache, use_cache=True)
-        return self.final
-
-    def __call__(self, h):
-        """h: [b, d] -> [b, d]. Differentiable in reverse mode."""
-        self.sub = h
-        try:
-            return self._decode(h.shape[0])
-        finally:
-            self.sub = None
-
-
-def jvp(f, x, v):
-    """J v via double backward.
-
-    torch.func.jvp cannot be used here: forward-mode duals do not survive the
-    module hooks that substitute the residual, and the model runs in bfloat16.
-    The double-backward identity d/du (J^T u) . v = J v needs only reverse mode,
-    which the hooks handle natively.
-    """
-    x = x.detach().requires_grad_(True)
-    y = f(x)
-    u = torch.zeros_like(y, requires_grad=True)
-    (g,) = torch.autograd.grad(y, x, grad_outputs=u, create_graph=True)
-    (out,) = torch.autograd.grad(g, u, grad_outputs=v)
-    return out
-
-
-def probes(d, r, seed, device):
-    """Nested Gaussian probes: spec 5.3 requires rank k's directions to be a
-    prefix of rank 2k's, so a rank sweep is a genuine refinement rather than an
-    unrelated redraw."""
-    g = torch.Generator(device="cpu").manual_seed(seed)
-    return torch.randn(d, r, generator=g).to(device)
-
-
-def estimate(model, blocks, layer, corpus, r, seed, chunk, device):
-    """Y = E_x[J_x Omega] then Q = qr(Y); B^T = E_x[J_x^T Q]."""
-    d = model.config.hidden_size
-    Om = probes(d, r, seed, device)
-    Y = torch.zeros(d, r, device=device, dtype=torch.float32)
-
-    maps = []
-    for ids in corpus:
-        tm = TailMap(model, blocks, layer, ids.unsqueeze(0))
-        maps.append(tm)
-
-    for tm in maps:
-        h0 = tm.baseline().float()
-        for s in range(0, r, chunk):
-            v = Om[:, s:s + chunk].T.contiguous()               # [b, d]
-            base = h0.expand(v.shape[0], d).contiguous()
-            Y[:, s:s + chunk] += jvp(lambda x: tm(x).float(), base, v).T.float()
-    Y /= len(maps)
-    Q, _ = torch.linalg.qr(Y.double())
-    Q = Q.float()                                               # [d, r]
-
-    Bt = torch.zeros(d, r, device=device, dtype=torch.float32)
-    for tm in maps:
-        h0 = tm.baseline().float()
-        for s in range(0, r, chunk):
-            w = Q[:, s:s + chunk].T.contiguous()
-            b = w.shape[0]
-            base = h0.expand(b, d).contiguous().requires_grad_(True)
-            outp = tm(base).float()
-            gr = torch.autograd.grad(outp, base, grad_outputs=w.float())[0]
-            Bt[:, s:s + chunk] += gr.T.float()
-    Bt /= len(maps)
-    for tm in maps:
-        tm.close()
-    return Q, Bt.T.contiguous()                                 # Q [d,r], B [r,d]
-
-
-def direct_action(model, blocks, layer, corpus, H, device):
-    """u_i = J h_i computed directly (spec 7.1) -- the validation reference.
-
-    Needs no d x d matrix: it is one JVP per held-out activation, averaged over
-    the same calibration corpus the estimator used.
-    """
-    d = model.config.hidden_size
-    U = torch.zeros(H.shape[0], d, device=device, dtype=torch.float32)
-    for ids in corpus:
-        tm = TailMap(model, blocks, layer, ids.unsqueeze(0))
-        h0 = tm.baseline().float()
-        for s in range(0, H.shape[0], 16):
-            v = H[s:s + 16].to(device).float()
-            base = h0.expand(v.shape[0], d).contiguous()
-            U[s:s + 16] += jvp(lambda x: tm(x).float(), base, v).float()
-        tm.close()
-    return U / len(corpus)
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--model", required=True)
-    ap.add_argument("--rank", type=int, default=256)
-    ap.add_argument("--seed", type=int, default=None)
-    ap.add_argument("--layers", nargs="*", type=int, default=None)
-    ap.add_argument("--n-prompts", type=int, default=None)
-    ap.add_argument("--chunk", type=int, default=32, help="probe columns per jvp call")
-    ap.add_argument("--dtype", default="auto", choices=["auto", "float32", "bfloat16"])
-    ap.add_argument("--validate", action="store_true",
-                    help="spec 7.1 direct-action check on held-out activations")
-    args = ap.parse_args()
-
-    C = mc.cfg()["jlens"]
-    seed = args.seed if args.seed is not None else C["estimator"]["primary_seed"]
-    n_prompts = args.n_prompts or C["corpus"]["n_prompts"]
-    p = C["estimator"]["oversampling"]
-    r = args.rank + p
-    device = "cuda"
-
-    model, tok = load_for_jacobian(args.model, args.dtype)
-    compute_dtype = str(next(model.parameters()).dtype).replace("torch.", "")
-    blocks = decoder_layers(model)
-    L, d = len(blocks), int(model.config.hidden_size)
-    if r > d:
-        r = d
-    window = args.layers if args.layers else mc.layer_window(L)
-
-    corpus, used = calibration_prompts(tok, n_prompts, C["corpus"]["seq_len"],
-                                       C["corpus"]["seed"])
-    print(f"[{args.model}] d={d} L={L} rank={args.rank}+{p}={r} "
-          f"corpus={n_prompts}x{C['corpus']['seq_len']} layers={len(window)}", flush=True)
-
-    for l in window:
-        t0 = time.time()
-        Q, B = estimate(model, blocks, l, corpus, r, seed, args.chunk, device)
-        dest = mc.out("jlens", args.model, f"L{l:03d}")
-        np.save(os.path.join(dest, "Q.npy"), Q.cpu().numpy().astype(np.float32))
-        np.save(os.path.join(dest, "B.npy"), B.cpu().numpy().astype(np.float32))
-        meta = {"model": args.model, "layer": l, "hidden_dimension": d,
-                "rank": args.rank, "oversampling": p, "stored_rank": r,
-                "power_iterations": C["estimator"]["power_iterations"],
-                "calibration_corpus": C["corpus"]["name"],
-                "calibration_corpus_size": n_prompts,
-                "calibration_sequence_length": C["corpus"]["seq_len"],
-                "calibration_sample_ids": used, "random_seed": seed,
-                "compute_dtype": compute_dtype,
-                "seconds": round(time.time() - t0, 1), "validated": None}
-        mc.write_json(os.path.join(dest, "metadata.json"), meta)
-        print(f"  L{l:03d}  Q{tuple(Q.shape)} B{tuple(B.shape)}  "
-              f"{meta['seconds']}s", flush=True)
-    print(f"[{args.model}] JLENS_DONE", flush=True)
-
-
-if __name__ == "__main__":
-    main()

ICLR dataset/metrics/joint.py

@@ -1,172 +0,0 @@
-#!/usr/bin/env python
-"""Do internal and external stability move together?   (protocol 12, 13.2)
-
-    python src/joint.py --transport raw
-
-Three levels, because they can disagree and each answers a different question:
-
-  1. ACROSS MODELS   Does a model with higher BCS also have higher ISS?
-                     n = number of evaluated models, so this is suggestive at
-                     best -- it is the weakest of the three.
-
-  2. WITHIN MODEL, ACROSS FACTS   Are the SAME facts unstable behaviourally and
-                     internally? This is the real test. A model can sit at the
-                     group mean while the two measures disagree completely
-                     fact by fact, and only this level would reveal it.
-
-  3. BY BEHAVIOUR GROUP   Protocol 13.2: mean ISS for Stable Correct vs Stable
-                     Wrong vs Stable Abstention vs Unstable. This is the table
-                     the paper needs, and it also separates the two ways a fact
-                     can be "stable": stably right and stably wrong should both
-                     show high ISS if internal state drives behaviour.
-
-Protocol 12 lists cells such as "BCS high / ISS low" -- consistent answers
-reached through inconsistent internal states. Reporting only a single pooled
-correlation would hide exactly those cases, so the per-model breakdown is
-printed even when the pooled number looks tidy.
-"""
-import os, sys, glob, json, argparse, collections
-
-import numpy as np
-from scipy.stats import spearmanr, pearsonr
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-import mcommon as mc
-
-GROUPS = ["Stable Correct", "Stable Wrong", "Stable Abstention",
-          "Stable Unresolved", "Unstable"]
-
-
-def load_pairs(model, transport, mode):
-    ip = mc.out("metrics", "iss", f"{model}.{transport}.{mode}.per_fact.jsonl")
-    bp = mc.out("metrics", "behavioral", f"{model}.{mode}.per_fact.jsonl")
-    if not (os.path.exists(ip) and os.path.exists(bp)):
-        return None
-    iss = {r["fact_id"]: r for r in mc.read_jsonl(ip)}
-    beh = {r["fact_id"]: r for r in mc.read_jsonl(bp)}
-    common = sorted(set(iss) & set(beh))
-    if len(common) < 20:
-        return None
-    return [{"fact_id": f, "relation": iss[f]["relation"],
-             "iss": iss[f]["iss"], "iss_late": iss[f]["iss_late"],
-             "bcs": beh[f]["bcs"], "bes": beh[f]["bes"],
-             "group": beh[f]["behavior_group"]} for f in common]
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--transport", choices=["raw", "jlens"], default="raw")
-    ap.add_argument("--coverage", choices=["complete_family", "full_set"], default=None)
-    args = ap.parse_args()
-
-    mode = args.coverage or mc.cfg()["headline_coverage"]
-    names = [m["name"] for m in mc.models_cfg()["evaluated_models"]]
-
-    per_model, model_level = {}, []
-    for m in names:
-        rows = load_pairs(m, args.transport, mode)
-        if rows is None:
-            continue
-        per_model[m] = rows
-        isum = json.load(open(mc.out("metrics", "iss",
-                                     f"{m}.{args.transport}.{mode}.summary.json")))
-        bsum = json.load(open(mc.out("metrics", "behavioral",
-                                     f"{m}.{mode}.summary.json")))
-        kp = mc.out("metrics", "kts", f"{m}.{args.transport}.{mode}.summary.json")
-        ksum = json.load(open(kp)) if os.path.exists(kp) else {}
-        model_level.append({
-            "model": m, "family": mc.model_entry(m).get("family"),
-            "params_b": mc.model_entry(m).get("params_b"),
-            "tuning": mc.model_entry(m).get("tuning"),
-            "iss": isum["iss"], "bcs": bsum["bcs"], "bes": bsum["bes"],
-            "kts": ksum.get("kts"), "kts_id": ksum.get("kts_id"),
-            "unstable_rate": bsum["unstable_rate"],
-            "stable_correct_rate": bsum["stable_correct_rate"],
-            "n_joined": len(rows)})
-
-    if not model_level:
-        raise SystemExit("no model has BOTH ISS and BCS/BES yet")
-
-    out = {"transport": args.transport, "coverage_mode": mode,
-           "n_models": len(model_level), "model_level": model_level}
-
-    # ---- level 1: across models
-    def corr(a, b):
-        a, b = np.asarray(a, float), np.asarray(b, float)
-        ok = np.isfinite(a) & np.isfinite(b)
-        if ok.sum() < 3:
-            return None
-        return {"spearman": float(spearmanr(a[ok], b[ok]).statistic),
-                "pearson": float(pearsonr(a[ok], b[ok]).statistic), "n": int(ok.sum())}
-
-    across = {}
-    for x in ("bcs", "bes", "unstable_rate", "stable_correct_rate"):
-        for y in ("iss", "kts", "kts_id"):
-            c = corr([r[x] for r in model_level], [r[y] for r in model_level])
-            if c:
-                across[f"{x}__{y}"] = c
-    out["across_models"] = across
-
-    # ---- level 2: within model, across facts
-    within, pooled = {}, []
-    for m, rows in per_model.items():
-        within[m] = {
-            "n_facts": len(rows),
-            "iss_vs_bcs": corr([r["iss"] for r in rows], [r["bcs"] for r in rows]),
-            "iss_vs_bes": corr([r["iss"] for r in rows], [r["bes"] for r in rows]),
-        }
-        # Standardise inside each model before pooling, otherwise the pooled
-        # correlation would mostly reflect between-model level differences
-        # rather than the within-model fact-by-fact association we are after.
-        for key in ("iss", "bcs"):
-            v = np.array([r[key] for r in rows], float)
-            sd = v.std() or 1.0
-            for r, z in zip(rows, (v - v.mean()) / sd):
-                r[f"z_{key}"] = float(z)
-        pooled += rows
-    out["within_model"] = within
-    out["pooled_within_model"] = corr([r["z_iss"] for r in pooled],
-                                      [r["z_bcs"] for r in pooled])
-
-    # ---- level 3: behaviour groups (protocol 13.2)
-    by_group = collections.defaultdict(list)
-    for m, rows in per_model.items():
-        for r in rows:
-            by_group[r["group"]].append(r["iss"])
-    out["iss_by_behavior_group"] = {
-        g: {"n": len(by_group[g]), "iss_mean": float(np.mean(by_group[g])),
-            "iss_sd": float(np.std(by_group[g]))}
-        for g in GROUPS if by_group[g]}
-    out["iss_by_behavior_group_per_model"] = {
-        m: {g: float(np.mean([r["iss"] for r in rows if r["group"] == g]))
-            for g in GROUPS if any(r["group"] == g for r in rows)}
-        for m, rows in per_model.items()}
-
-    mc.write_json(mc.out("metrics", f"joint_internal_external.{args.transport}.{mode}.json"),
-                  out)
-
-    # ------------------------------------------------------------ report
-    print(f"\n=== 1. ACROSS MODELS (n={len(model_level)}) ===")
-    print(f"{'pair':34s} {'Spearman':>9s} {'Pearson':>9s}")
-    for k, v in across.items():
-        print(f"{k:34s} {v['spearman']:>9.3f} {v['pearson']:>9.3f}")
-
-    print(f"\n=== 2. WITHIN MODEL, ACROSS FACTS ===")
-    print(f"{'model':30s} {'n':>5s} {'ISSvBCS':>8s} {'ISSvBES':>8s}")
-    for m, v in within.items():
-        a = v["iss_vs_bcs"]["spearman"] if v["iss_vs_bcs"] else float("nan")
-        b = v["iss_vs_bes"]["spearman"] if v["iss_vs_bes"] else float("nan")
-        print(f"{m:30s} {v['n_facts']:>5d} {a:>8.3f} {b:>8.3f}")
-    p = out["pooled_within_model"]
-    if p:
-        print(f"{'POOLED (z-scored per model)':30s} {p['n']:>5d} {p['spearman']:>8.3f}")
-
-    print(f"\n=== 3. ISS BY BEHAVIOUR GROUP (protocol 13.2) ===")
-    print(f"{'group':22s} {'facts':>7s} {'ISS mean':>9s} {'sd':>7s}")
-    for g, v in out["iss_by_behavior_group"].items():
-        print(f"{g:22s} {v['n']:>7d} {v['iss_mean']:>9.3f} {v['iss_sd']:>7.3f}")
-    print()
-
-
-if __name__ == "__main__":
-    main()

ICLR dataset/metrics/judge_run.py

@@ -1,273 +0,0 @@
-#!/usr/bin/env python
-"""AI Judge: semantic answer clustering, then correctness.   [GPU]  (protocol 3)
-
-    python src/judge_run.py --model Llama-3.2-1B
-
-Two passes, in the order protocol 3 mandates:
-
-  Pass 1  REFERENCE-BLIND. The judge never sees the gold answer. It only groups
-          responses that assert the same thing -- "Paris", "The answer is
-          Paris.", "巴黎" -- and flags ABSTAIN / MULTIPLE / UNPARSEABLE.
-          This is what BCS and BES are built on, and keeping gold out of it is
-          what lets a confidently wrong model score BCS = 1.
-
-  Pass 2  REFERENCE-AWARE. Gold, aliases, answer type and granularity are
-          supplied, and each CLUSTER (not each response) is labelled. This only
-          separates Stable Correct from Stable Wrong; it never reshapes a
-          cluster.
-
-The unit of judgement is the (fact, model) pair, per protocol 3.1: judging pairs
-of responses independently would produce non-transitive verdicts, where a~b and
-b~c but a!~c, and no consistent cluster assignment exists.
-
-Cost control: responses are pre-grouped by normalised surface string before the
-judge sees them. Exact post-normalisation identity is a strict subset of
-semantic equivalence, so the judge can only ever merge those groups further,
-never split them -- the clustering is unchanged, but a typical fact sends 3-6
-distinct strings instead of 17 responses.
-"""
-import os, sys, json, time, argparse, re
-
-import torch
-from transformers import AutoModelForCausalLM, AutoTokenizer
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-import mcommon as mc
-sys.path.insert(0, mc.ds3("src"))
-from common import normalize                       # noqa: E402
-
-BLIND = """You are clustering short answers to one factual question. You are NOT told the correct answer and must not guess it.
-
-Question: {question}
-
-Candidate answers:
-{answers}
-
-Work in two steps, exactly as follows.
-
-Step 1. For each answer, extract ONLY the core entity or value it finally asserts. Strip restated question text, subject names, hedging, reasoning and trailing explanation. "Agriculture and Agri-Food Canada applies in Canada" asserts "Canada". "The answer is Paris." asserts "Paris".
-
-Step 2. Group the answers whose EXTRACTED core is the same entity or value. Ignore wording, language, punctuation and capitalisation; translations of one another belong together, and a bare entity belongs with a full sentence asserting that same entity. Two answers go in different groups only when they name genuinely different entities.
-
-Use these special groups where they apply:
-- ABSTAIN: refuses, or says it does not know
-- MULTIPLE: gives several conflicting answers without choosing
-- UNPARSEABLE: no answer can be extracted
-
-Reply with JSON only, where "meaning" is the extracted core from step 1:
-{{"clusters":[{{"ids":[0,2],"meaning":"Paris","status":"ANSWER"}},{{"ids":[1],"meaning":"","status":"ABSTAIN"}}]}}
-Every id from 0 to {last} must appear exactly once."""
-
-AWARE = """Judge whether each proposed answer is correct for this question.
-
-Question: {question}
-Correct answer: {gold}
-Also acceptable: {aliases}
-Answer type: {atype} ({gran})
-
-Proposed answers:
-{answers}
-
-Label each one:
-- CORRECT: same entity/value as the correct answer, any wording or language
-- INCORRECT: a different entity/value
-- ABSTAIN: a refusal or "I don't know"
-- AMBIGUOUS: could refer to the correct answer but is too vague to tell
-- REVIEW_REQUIRED: cannot decide
-
-Reply with JSON only: {{"labels":["CORRECT","INCORRECT"]}} with exactly {n} entries in order."""
-
-
-def parse_json(text):
-    """Judges emit prose around the JSON often enough that this must be robust."""
-    m = re.search(r"\{.*\}", text, re.S)
-    if not m:
-        return None
-    try:
-        return json.loads(m.group(0))
-    except json.JSONDecodeError:
-        try:
-            return json.loads(re.sub(r",\s*([}\]])", r"\1", m.group(0)))
-        except json.JSONDecodeError:
-            return None
-
-
-def generate(model, tok, prompts, max_new, batch):
-    outs = []
-    for i in range(0, len(prompts), batch):
-        chunk = prompts[i:i + batch]
-        texts = [tok.apply_chat_template([{"role": "user", "content": p}],
-                                         tokenize=False, add_generation_prompt=True)
-                 for p in chunk]
-        enc = tok(texts, return_tensors="pt", padding=True, truncation=True,
-                  max_length=2048).to(0)
-        with torch.no_grad():
-            g = model.generate(**enc, max_new_tokens=max_new, do_sample=False,
-                               num_beams=1, pad_token_id=tok.pad_token_id)
-        outs += tok.batch_decode(g[:, enc["input_ids"].shape[1]:],
-                                 skip_special_tokens=True)
-    return outs
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--model", required=True, help="the model being judged")
-    ap.add_argument("--judge", default=None)
-    ap.add_argument("--batch", type=int, default=32)
-    ap.add_argument("--limit", type=int, default=0, help="debug: first N facts")
-    ap.add_argument("--sample", type=int, default=0,
-                    help="judge a fixed random subset of facts instead of all 2,592")
-    ap.add_argument("--sample-seed", type=int, default=20260101)
-    ap.add_argument("--resume", action="store_true")
-    args = ap.parse_args()
-
-    judge_name = args.judge or mc.models_cfg()["auxiliary_models"]["judge"]["name"]
-    if judge_name == args.model:
-        raise SystemExit("the judge must not judge itself (MODEL_SELECTION_20 section 6)")
-
-    fams = set(mc.cfg()["main_families"])
-    gen_path = mc.ds3("outputs", "evaluation", f"{args.model}.jsonl")
-    if not os.path.exists(gen_path):
-        raise SystemExit(f"no generations for {args.model}: {gen_path}")
-
-    qmeta = {r["query_id"]: r for r in mc.main_forward_queries()}
-    by_fact = {}
-    for r in mc.read_jsonl(gen_path):
-        if r["condition_family"] not in fams or r["query_id"] not in qmeta:
-            continue
-        by_fact.setdefault(r["fact_id"], []).append(r)
-    fact_ids = sorted(by_fact)
-    if args.sample and args.sample < len(fact_ids):
-        # Drawn from the FULL benchmark fact list with a fixed seed, not from
-        # this model's own facts, so every model is judged on an identical
-        # subset. Sampling per model would make BCS/BES incomparable, which is
-        # exactly what protocol 1.3 forbids.
-        import numpy as np
-        allf = sorted(mc.facts())
-        rng = np.random.default_rng(args.sample_seed)
-        pick = set(np.array(allf)[rng.choice(len(allf), size=args.sample,
-                                             replace=False)].tolist())
-        fact_ids = [f for f in fact_ids if f in pick]
-    if args.limit:
-        fact_ids = fact_ids[:args.limit]
-
-    dest = mc.out("metrics", "judge", f"{args.model}.jsonl")
-    done = set()
-    if args.resume and os.path.exists(dest):
-        done = {r["fact_id"] for r in mc.read_jsonl(dest)}
-        fact_ids = [f for f in fact_ids if f not in done]
-    if not fact_ids:
-        print(f"[{args.model}] judge already complete")
-        return
-
-    facts = mc.facts()
-    # Pre-group by normalised surface: a strict subset of semantic equivalence,
-    # so this changes cost and not the clustering the judge can express.
-    tasks = []
-    for fid in fact_ids:
-        recs = by_fact[fid]
-        groups = {}
-        for r in recs:
-            key = normalize(r["raw_response"].strip().split("\n")[0][:120])
-            groups.setdefault(key, []).append(r["query_id"])
-        surfaces = list(groups)
-        display = [next(x["raw_response"].strip().split("\n")[0][:120]
-                        for x in recs if normalize(
-                            x["raw_response"].strip().split("\n")[0][:120]) == s) or "(empty)"
-                   for s in surfaces]
-        tasks.append({"fact_id": fid, "surfaces": surfaces, "display": display,
-                      "groups": [groups[s] for s in surfaces],
-                      "question": facts[fid]["qualification_question"]})
-
-    path = mc.model_path(judge_name)
-    tok = AutoTokenizer.from_pretrained(path)
-    if tok.pad_token is None:
-        tok.pad_token = tok.eos_token
-    tok.padding_side = "left"
-    judge = AutoModelForCausalLM.from_pretrained(
-        path, dtype=torch.bfloat16, device_map={"": 0}).eval()
-
-    t0 = time.time()
-    out_f = open(dest, "a" if done else "w")
-    for i in range(0, len(tasks), args.batch):
-        chunk = tasks[i:i + args.batch]
-
-        p1 = [BLIND.format(question=t["question"], last=len(t["display"]) - 1,
-                           answers="\n".join(f"{j}. {d}" for j, d in enumerate(t["display"])))
-              for t in chunk]
-        r1 = generate(judge, tok, p1, 512, args.batch)
-
-        for t, raw in zip(chunk, r1):
-            js = parse_json(raw) or {}
-            clusters, seen = [], set()
-            for c in js.get("clusters", []):
-                ids = [int(x) for x in c.get("ids", [])
-                       if isinstance(x, (int, float)) and 0 <= int(x) < len(t["display"])
-                       and int(x) not in seen]
-                if not ids:
-                    continue
-                seen.update(ids)
-                clusters.append({"ids": ids, "meaning": str(c.get("meaning", ""))[:80],
-                                 "status": str(c.get("status", "ANSWER")).upper()})
-            # Anything the judge dropped or mangled stays its own cluster rather
-            # than vanishing: silently losing a response would change the BCS
-            # denominator for that fact.
-            for j in range(len(t["display"])):
-                if j not in seen:
-                    clusters.append({"ids": [j], "meaning": t["display"][j][:80],
-                                     "status": "ANSWER", "recovered": True})
-            t["clusters"] = clusters
-            t["judge_raw_blind"] = raw[:400]
-
-        p2, own = [], []
-        for t in chunk:
-            f = facts[t["fact_id"]]
-            answer = [c["meaning"] or t["display"][c["ids"][0]] for c in t["clusters"]]
-            p2.append(AWARE.format(
-                question=t["question"], gold=f["object"]["canonical"],
-                aliases=", ".join(f["object"]["aliases"][:10]),
-                atype=f.get("answer_type", "entity"),
-                gran=f.get("answer_granularity", "entity"),
-                answers="\n".join(f"{j}. {a}" for j, a in enumerate(answer)),
-                n=len(answer)))
-            own.append(t)
-        r2 = generate(judge, tok, p2, 256, args.batch)
-        for t, raw in zip(own, r2):
-            js = parse_json(raw) or {}
-            labels = [str(x).upper() for x in js.get("labels", [])]
-            for j, c in enumerate(t["clusters"]):
-                lab = labels[j] if j < len(labels) else "REVIEW_REQUIRED"
-                if c["status"] in ("ABSTAIN", "MULTIPLE", "UNPARSEABLE"):
-                    lab = c["status"] if c["status"] == "ABSTAIN" else "REVIEW_REQUIRED"
-                c["correctness"] = lab
-            t["judge_raw_aware"] = raw[:400]
-
-        for t in chunk:
-            rows = []
-            for k, c in enumerate(t["clusters"]):
-                cid = f"C{k}" if c["status"] == "ANSWER" else c["status"]
-                for j in c["ids"]:
-                    for qid in t["groups"][j]:
-                        rows.append({"query_id": qid,
-                                     "condition_family": qmeta[qid]["condition_family"],
-                                     "cluster_id": cid})
-            out_f.write(json.dumps({
-                "model": args.model, "judge": judge_name, "fact_id": t["fact_id"],
-                "clusters": [{"cluster_id": f"C{k}" if c["status"] == "ANSWER"
-                              else c["status"],
-                              "canonical_meaning": c["meaning"],
-                              "status": c["status"],
-                              "correctness": c.get("correctness", "REVIEW_REQUIRED")}
-                             for k, c in enumerate(t["clusters"])],
-                "assignments": rows}, ensure_ascii=False) + "\n")
-        out_f.flush()
-        d = i + len(chunk)
-        print(f"  {d}/{len(tasks)} facts  {d / max(time.time() - t0, 1e-9):.2f}/s",
-              flush=True)
-    out_f.close()
-    print(f"[{args.model}] judged {len(tasks)} facts with {judge_name}  JUDGE_DONE",
-          flush=True)
-
-
-if __name__ == "__main__":
-    main()

ICLR dataset/metrics/kts.py

@@ -1,190 +0,0 @@
-#!/usr/bin/env python
-"""KTS: Knowledge Topology Stability.   (protocol 8-11)
-
-    python src/kts.py --model Llama-3.2-1B --transport raw
-    python src/kts.py --model Llama-3.2-1B --transport jlens
-
-Two components, both computed per relation and then macro-averaged so that the
-largest relations cannot dominate (protocol 9.1):
-
-  KTS-Geo  Spearman correlation between the within-relation pairwise distance
-           matrices under the two condition families. Rotation, translation and
-           isotropic scaling are all invisible to it -- protocol 8.1 says that
-           is intended: different phrasings may use different internal
-           implementations as long as relative structure survives.
-
-  KTS-ID   Cross-condition nearest-neighbour retrieval of the fact itself,
-           among same-relation facts, both directions, chance-corrected.
-           Global geometry can look preserved while individual identities swap,
-           which is exactly what this catches.
-
-composite = harmonic mean of the two, so a model cannot buy a high KTS with one
-component alone (protocol 11).
-"""
-import os, sys, json, time, argparse, itertools
-
-import numpy as np
-import torch
-from scipy.stats import spearmanr
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-import mcommon as mc
-from states import StateLoader
-
-
-def geo_pair(Va, Vb, members, eps):
-    """Spearman between within-relation distance matrices (protocol 9.1-9.2)."""
-    idx = torch.tensor(members, device=Va.device)
-    A, B = Va[idx], Vb[idx]
-    Da = 1.0 - (A @ A.T)
-    Db = 1.0 - (B @ B.T)
-    iu = torch.triu_indices(len(members), len(members), offset=1)
-    da = Da[iu[0], iu[1]].cpu().numpy()
-    db = Db[iu[0], iu[1]].cpu().numpy()
-    if da.size < 2 or np.std(da) < eps or np.std(db) < eps:
-        return None
-    rho = spearmanr(da, db).statistic
-    return None if not np.isfinite(rho) else float(rho)
-
-
-def id_pair(Va, Vb, members):
-    """Symmetric chance-corrected top-1 identity, plus top-5 and MRR.
-
-    Retrieval is restricted to same-relation facts (protocol 10.1): matching
-    "the capital of France" against a manufacturer fact would be trivial and
-    would inflate the score.
-    """
-    idx = torch.tensor(members, device=Va.device)
-    A, B = Va[idx], Vb[idx]
-    n = len(members)
-    gold = torch.arange(n, device=A.device)
-
-    def side(X, Y):
-        S = X @ Y.T
-        rank = (S > S.gather(1, gold[:, None])).sum(1)      # 0 = correct is top
-        top1 = (rank == 0).float().mean().item()
-        top5 = (rank < 5).float().mean().item()
-        mrr = (1.0 / (rank.float() + 1)).mean().item()
-        return top1, top5, mrr
-
-    a = side(A, B)
-    b = side(B, A)
-    top1 = 0.5 * (a[0] + b[0])
-    chance = 1.0 / n
-    adj = (top1 - chance) / max(1.0 - chance, 1e-12)
-    return {"top1_symmetric": top1, "top5_symmetric": 0.5 * (a[1] + b[1]),
-            "mrr_symmetric": 0.5 * (a[2] + b[2]), "chance": chance,
-            "chance_corrected": float(np.clip(adj, 0.0, 1.0)), "n": n}
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--model", required=True)
-    ap.add_argument("--transport", choices=["raw", "jlens"], default="raw")
-    ap.add_argument("--coverage", choices=["complete_family", "full_set"], default=None)
-    ap.add_argument("--device", default="auto")
-    ap.add_argument("--shuffle-seed", type=int, default=None,
-                    help="protocol 18.1 control: KTS-ID must fall to chance, KTS-Geo to ~0")
-    args = ap.parse_args()
-
-    C = mc.cfg()
-    kcfg = C["kts"]
-    eps = float(kcfg["eps"])
-    min_facts = kcfg["min_facts_per_relation"]
-
-    S = StateLoader(args.model, args.transport, args.coverage, args.device,
-                    shuffle_seed=args.shuffle_seed)
-    fams = S.families
-    pairs = list(itertools.combinations(range(len(fams)), 2))
-
-    t0 = time.time()
-    per_layer_pair = []
-    for l in S.window:
-        V, mask = S.centroids(l)
-        for (a, b) in pairs:
-            both = mask[:, a] & mask[:, b]
-            geos, ids, shared = [], [], int(both.sum())
-            for rel, members in S.by_rel.items():
-                m = [i for i in members if bool(both[i])]
-                if len(m) < min_facts:          # protocol 9.1
-                    continue
-                g = geo_pair(V[:, a], V[:, b], m, eps)
-                if g is not None:
-                    geos.append(g)
-                ids.append(id_pair(V[:, a], V[:, b], m))
-            if not geos or not ids:
-                continue
-            geo = float(np.mean(geos))
-            geo01 = (geo + 1.0) / 2.0                       # protocol 9.3
-            idv = float(np.mean([x["chance_corrected"] for x in ids]))
-            per_layer_pair.append({
-                "model": args.model, "transport": args.transport, "layer": l,
-                "pair": f"{fams[a]}__{fams[b]}", "shared_facts": shared,
-                "relations_used": len(ids),
-                "kts_geo_raw": geo, "kts_geo": geo01, "kts_id": idv,
-                "kts": 2 * geo01 * idv / (geo01 + idv + eps),   # protocol 11
-                "top1": float(np.mean([x["top1_symmetric"] for x in ids])),
-                "top5": float(np.mean([x["top5_symmetric"] for x in ids])),
-                "mrr": float(np.mean([x["mrr_symmetric"] for x in ids])),
-            })
-        del V, mask
-        if S.dev == "cuda":
-            torch.cuda.empty_cache()
-        lay = [r for r in per_layer_pair if r["layer"] == l]
-        print(f"  L{l:03d}  geo={np.mean([r['kts_geo'] for r in lay]):.4f}  "
-              f"id={np.mean([r['kts_id'] for r in lay]):.4f}  "
-              f"kts={np.mean([r['kts'] for r in lay]):.4f}", flush=True)
-
-    tag = f"{args.model}.{args.transport}.{S.mode}"
-    if args.shuffle_seed is not None:
-        tag += f".shuffled{args.shuffle_seed}"
-    mc.write_jsonl(mc.out("metrics", "kts", f"{tag}.per_pair_layer.jsonl"), per_layer_pair)
-
-    # Protocol 11.1: every family pair counts equally. Weighting by shared facts
-    # would let the widest-coverage pairs decide the number.
-    def agg(rows, key):
-        by_layer = {}
-        for r in rows:
-            by_layer.setdefault(r["layer"], []).append(r[key])
-        return float(np.mean([np.mean(v) for v in by_layer.values()]))
-
-    pair_summary = {}
-    for p in sorted({r["pair"] for r in per_layer_pair}):
-        rows = [r for r in per_layer_pair if r["pair"] == p]
-        pair_summary[p] = {
-            "shared_facts": rows[0]["shared_facts"],
-            "kts_geo": float(np.mean([r["kts_geo"] for r in rows])),
-            "kts_geo_raw": float(np.mean([r["kts_geo_raw"] for r in rows])),
-            "kts_id": float(np.mean([r["kts_id"] for r in rows])),
-            "kts": float(np.mean([r["kts"] for r in rows])),
-            "top1": float(np.mean([r["top1"] for r in rows])),
-            "top5": float(np.mean([r["top5"] for r in rows])),
-            "mrr": float(np.mean([r["mrr"] for r in rows])),
-        }
-
-    summary = {
-        "model": args.model, "transport": args.transport,
-        "official": args.transport == "jlens" and args.shuffle_seed is None,
-        "shuffle_control": args.shuffle_seed is not None, "coverage_mode": S.mode,
-        "layers": S.window, "n_facts": S.n_facts,
-        "kts_geo": agg(per_layer_pair, "kts_geo"),
-        "kts_geo_raw_spearman": agg(per_layer_pair, "kts_geo_raw"),
-        "kts_id": agg(per_layer_pair, "kts_id"),
-        "kts": agg(per_layer_pair, "kts"),
-        "top1": agg(per_layer_pair, "top1"),
-        "top5": agg(per_layer_pair, "top5"),
-        "mrr": agg(per_layer_pair, "mrr"),
-        "family_pairs": pair_summary,
-        "per_layer_kts": {str(l): float(np.mean([r["kts"] for r in per_layer_pair
-                                                 if r["layer"] == l]))
-                          for l in S.window},
-        "seconds": round(time.time() - t0, 1),
-    }
-    mc.write_json(mc.out("metrics", "kts", f"{tag}.summary.json"), summary)
-    print(f"[{args.model}] {args.transport}  KTS-Geo={summary['kts_geo']:.4f}  "
-          f"KTS-ID={summary['kts_id']:.4f}  KTS={summary['kts']:.4f}  KTS_DONE",
-          flush=True)
-
-
-if __name__ == "__main__":
-    main()

ICLR dataset/metrics/make_table.py

@@ -1,106 +0,0 @@
-#!/usr/bin/env python
-"""The main results table: model x {BCS, BES, ISS, KTS}.   (protocol 13, 20)
-
-    python src/make_table.py                 # markdown to stdout + outputs/
-    python src/make_table.py --transport raw # the ablation table
-
-ISS is reported from the J-Lens transported states. Raw-ISS is an
-identity-transport ablation and is labelled as such (J-Lens spec 11); a model
-whose J-Lens estimator failed validation shows "--" for ISS rather than a raw
-number wearing the official name (spec 12).
-"""
-import os, sys, json, argparse
-
-import numpy as np
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-import mcommon as mc
-
-
-def load(kind, name):
-    p = mc.out("metrics", kind, name)
-    return json.load(open(p)) if os.path.exists(p) else None
-
-
-def fmt(v, nd=3, pct=False):
-    if v is None or (isinstance(v, float) and not np.isfinite(v)):
-        return "--"
-    return f"{100 * v:.1f}" if pct else f"{v:.{nd}f}"
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--transport", choices=["jlens", "raw"], default="jlens")
-    ap.add_argument("--coverage", choices=["complete_family", "full_set"], default=None)
-    ap.add_argument("--models", nargs="*", default=None)
-    args = ap.parse_args()
-
-    C = mc.cfg()
-    mode = args.coverage or C["headline_coverage"]
-    names = args.models or [m["name"] for m in mc.models_cfg()["evaluated_models"]]
-
-    rows = []
-    for m in names:
-        beh = load("behavioral", f"{m}.{mode}.summary.json")
-        iss = load("iss", f"{m}.{args.transport}.{mode}.summary.json")
-        kts = load("kts", f"{m}.{args.transport}.{mode}.summary.json")
-        if not any([beh, iss, kts]):
-            continue
-        e = mc.model_entry(m)
-        rows.append({
-            "model": m, "family": e.get("family", ""), "tier": e.get("tier", ""),
-            "params_b": e.get("params_b"), "tuning": e.get("tuning", ""),
-            "bcs": beh and beh["bcs"], "bes": beh and beh["bes"],
-            "scr": beh and beh["stable_correct_rate"],
-            "swr": beh and beh["stable_wrong_rate"],
-            "sar": beh and beh["stable_abstention_rate"],
-            "ur": beh and beh["unstable_rate"],
-            "iss": iss and iss["iss"], "iss_ci": iss and iss["iss_ci95"],
-            "iss_peak": iss and iss["iss_peak"], "iss_late": iss and iss["iss_late"],
-            "kts_geo": kts and kts["kts_geo"], "kts_id": kts and kts["kts_id"],
-            "kts": kts and kts["kts"],
-            "n_facts": (beh or iss or kts).get("n_facts"),
-        })
-    if not rows:
-        raise SystemExit("nothing to tabulate yet")
-    rows.sort(key=lambda r: (r["family"], r["params_b"] or 0))
-
-    label = "ISS (J-Lens)" if args.transport == "jlens" else "Raw-ISS (ablation)"
-    L = []
-    L.append(f"# BCS / BES / ISS / KTS  ({mode}, transport={args.transport})\n")
-    L.append(f"Fact set: fixed benchmark, {rows[0]['n_facts']} facts scored per model. "
-             f"ISS column is **{label}**.\n")
-    L.append("| Model | Family | Tier | BCS | BES | " + label +
-             " | KTS-Geo | KTS-ID | KTS |")
-    L.append("|---|---|---|---:|---:|---:|---:|---:|---:|")
-    for r in rows:
-        L.append(f"| {r['model']} | {r['family']} | {r['tier']} | "
-                 f"{fmt(r['bcs'])} | {fmt(r['bes'])} | {fmt(r['iss'])} | "
-                 f"{fmt(r['kts_geo'])} | {fmt(r['kts_id'])} | {fmt(r['kts'])} |")
-
-    L.append("\n## Behaviour composition (protocol 6, %)\n")
-    L.append("| Model | Stable Correct | Stable Wrong | Stable Abstention | Unstable |")
-    L.append("|---|---:|---:|---:|---:|")
-    for r in rows:
-        L.append(f"| {r['model']} | {fmt(r['scr'], pct=True)} | {fmt(r['swr'], pct=True)} "
-                 f"| {fmt(r['sar'], pct=True)} | {fmt(r['ur'], pct=True)} |")
-
-    L.append("\n## ISS detail (protocol 7.10)\n")
-    L.append("| Model | ISS | 95% CI | Peak | Late |")
-    L.append("|---|---:|---|---:|---:|")
-    for r in rows:
-        ci = f"[{fmt(r['iss_ci'][0])}, {fmt(r['iss_ci'][1])}]" if r["iss_ci"] else "--"
-        L.append(f"| {r['model']} | {fmt(r['iss'])} | {ci} | "
-                 f"{fmt(r['iss_peak'])} | {fmt(r['iss_late'])} |")
-
-    md = "\n".join(L) + "\n"
-    dest = mc.out("metrics", f"main_table.{args.transport}.{mode}.md")
-    with open(dest, "w") as f:
-        f.write(md)
-    mc.write_json(mc.out("metrics", f"main_table.{args.transport}.{mode}.json"), rows)
-    print(md)
-    print(f"written -> {dest}")
-
-
-if __name__ == "__main__":
-    main()

ICLR dataset/metrics/mcommon.py

@@ -1,252 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Shared plumbing for the BCS/BES/ISS/KTS metric stack.
-
-Everything here is deliberately read-only with respect to dataset3/: the fact
-set and the query bank are frozen artefacts (protocol 2.1), and this package
-only consumes them.
-"""
-import os, json, math, functools
-
-import numpy as np
-import yaml
-
-HERE = os.path.dirname(os.path.abspath(__file__))
-ROOT = os.path.dirname(HERE)
-CONFIGS = os.path.join(ROOT, "configs")
-
-
-@functools.lru_cache(maxsize=None)
-def cfg():
-    with open(os.path.join(CONFIGS, "metrics.yaml")) as f:
-        return yaml.safe_load(f)
-
-
-@functools.lru_cache(maxsize=None)
-def models_cfg():
-    with open(os.path.join(cfg()["paths"]["dataset3"], "configs", "models.yaml")) as f:
-        return yaml.safe_load(f)
-
-
-def model_entry(name):
-    for m in models_cfg()["evaluated_models"]:
-        if m["name"] == name:
-            return m
-    aux = models_cfg().get("auxiliary_models", {})
-    for m in aux.values():
-        if m["name"] == name:
-            return m
-    raise KeyError(f"{name} is not in dataset3/configs/models.yaml")
-
-
-def model_path(name):
-    return os.path.join(models_cfg()["model_root"], model_entry(name)["path"])
-
-
-def ds3(*parts):
-    return os.path.join(cfg()["paths"]["dataset3"], *parts)
-
-
-def out(kind, *parts):
-    """kind in {hidden, jlens, metrics}."""
-    p = os.path.join(cfg()["paths"][f"{kind}_root"], *parts)
-    os.makedirs(os.path.dirname(p) if os.path.splitext(p)[1] else p, exist_ok=True)
-    return p
-
-
-def read_jsonl(path):
-    with open(path) as f:
-        for line in f:
-            line = line.strip()
-            if line:
-                yield json.loads(line)
-
-
-def write_jsonl(path, rows):
-    os.makedirs(os.path.dirname(path), exist_ok=True)
-    n = 0
-    with open(path, "w") as f:
-        for r in rows:
-            f.write(json.dumps(r, ensure_ascii=False, default=_jsonable) + "\n")
-            n += 1
-    return n
-
-
-def write_json(path, obj):
-    os.makedirs(os.path.dirname(path), exist_ok=True)
-    with open(path, "w") as f:
-        json.dump(obj, f, indent=2, ensure_ascii=False, default=_jsonable)
-
-
-def _jsonable(o):
-    if isinstance(o, (np.floating, np.integer)):
-        return o.item()
-    if isinstance(o, np.ndarray):
-        return o.tolist()
-    raise TypeError(type(o))
-
-
-# ------------------------------------------------------------------- queries
-QUERY_BANK = "evaluation_queries_44418.jsonl"   # 44,416 rows; see dataset3 D1
-
-
-@functools.lru_cache(maxsize=None)
-def main_forward_queries():
-    """The 39,260 queries that protocol 1.1 admits to the main analysis.
-
-    The filter reads each row's own `use_for_main_forward` flag rather than
-    testing `condition_family in main_families`: the flags are derived from
-    eval_conditions.yaml and are what dataset3's validator checks, so trusting
-    them keeps one definition of the split instead of two that can drift.
-    """
-    rows = []
-    for r in read_jsonl(ds3("outputs", QUERY_BANK)):
-        if r.get("use_for_main_forward"):
-            rows.append(r)
-    fams = set(cfg()["main_families"])
-    bad = {r["condition_family"] for r in rows} - fams
-    if bad:
-        raise SystemExit(f"main_forward rows carry unexpected families: {bad}")
-    return rows
-
-
-@functools.lru_cache(maxsize=None)
-def facts():
-    """fact_id -> record, plus the relation of each fact."""
-    return {r["fact_id"]: r for r in read_jsonl(ds3("outputs", "benchmark_facts_2592.jsonl"))}
-
-
-@functools.lru_cache(maxsize=None)
-def fact_relation():
-    return {fid: r["relation"]["relation_id"] for fid, r in facts().items()}
-
-
-@functools.lru_cache(maxsize=None)
-def coverage():
-    """fact_id -> set of main families that actually contain it.
-
-    Protocol 1.3: coverage is ragged (multilingual 2,402, context 2,591), and
-    the two reporting modes below are both mandatory.
-    """
-    cov = {}
-    for r in main_forward_queries():
-        cov.setdefault(r["fact_id"], set()).add(r["condition_family"])
-    return cov
-
-
-@functools.lru_cache(maxsize=None)
-def complete_family_facts():
-    """D_cap: the facts carrying all five main families (protocol 1.3).
-
-    This set is a property of the query bank, not of any model, so every model
-    is scored on exactly the same facts -- which is the point of protocol 1.3's
-    prohibition on per-model effective sets.
-    """
-    need = set(cfg()["main_families"])
-    return sorted(f for f, c in coverage().items() if c >= need)
-
-
-def eval_fact_set(mode):
-    if mode == "complete_family":
-        return complete_family_facts()
-    if mode == "full_set":
-        return sorted(coverage())
-    raise ValueError(mode)
-
-
-# -------------------------------------------------------------- layer window
-def layer_window(n_layers, min_depth=None):
-    """Protocol 7.10: {l : d_l >= min_depth}, d_l = l / (L - 1).
-
-    `l` indexes decoder blocks 0..L-1, so l = L-1 is the final residual stream
-    that J-Lens transports to. In HF terms the state is hidden_states[l+1],
-    because hidden_states[0] is the embedding output.
-    """
-    if min_depth is None:
-        min_depth = cfg()["extraction"]["window_min_depth"]
-    return [l for l in range(n_layers) if l / max(n_layers - 1, 1) >= min_depth - 1e-9]
-
-
-def late_window(n_layers):
-    return layer_window(n_layers, cfg()["extraction"]["late_min_depth"])
-
-
-# --------------------------------------------------------------- linear alg
-def l2_normalize(x, axis=-1, eps=1e-12):
-    n = np.linalg.norm(x, axis=axis, keepdims=True)
-    return x / np.maximum(n, eps)
-
-
-def pca_whiten(X, dim, shrinkage, eps=1e-12):
-    """Return the whitened matrix and the fitted transform.
-
-    Protocol 7.5 forbids fitting a separate transform per condition family, so
-    this is called once per (model, layer) on the pooled matrix and the same
-    components are then applied to every family.
-    """
-    mu = X.mean(axis=0, keepdims=True)
-    Xc = X - mu
-    # Economy SVD on the centred matrix is the covariance eigendecomposition
-    # without ever forming a d x d matrix -- d can be 5120 and n is ~39k.
-    k = min(dim, Xc.shape[0], Xc.shape[1])
-    U, S, Vt = np.linalg.svd(Xc, full_matrices=False)
-    U, S, Vt = U[:, :k], S[:k], Vt[:k]
-    var = (S ** 2) / max(Xc.shape[0] - 1, 1)
-    # lambda is expressed as a fraction of the mean retained variance so that
-    # one config value behaves the same across models with different scales.
-    lam = shrinkage * float(var.mean())
-    Z = (Xc @ Vt.T) / np.sqrt(var + lam + eps)
-    return Z.astype(np.float32), {"mean": mu, "components": Vt, "scale": np.sqrt(var + lam + eps)}
-
-
-# ------------------------------------------------------------------ negatives
-def negative_sample(fact_ids, relation_of, max_negatives, seed):
-    """Protocol 7.8: for each fact, up to `max_negatives` same-relation others.
-
-    Drawn ONCE from the fixed fact set and reused for every model. If each model
-    drew its own, a model could score well merely by having been handed more
-    distant negatives.
-    """
-    rng = np.random.default_rng(seed)
-    by_rel = {}
-    for f in fact_ids:
-        by_rel.setdefault(relation_of[f], []).append(f)
-    for r in by_rel:
-        by_rel[r].sort()
-    negs = {}
-    for f in fact_ids:
-        pool = [g for g in by_rel[relation_of[f]] if g != f]
-        if len(pool) > max_negatives:
-            idx = rng.choice(len(pool), size=max_negatives, replace=False)
-            pool = [pool[i] for i in sorted(idx)]
-        negs[f] = pool
-    return negs
-
-
-# ----------------------------------------------------------------- bootstrap
-def relation_clustered_bootstrap(values, relation_of, n_resamples, seed, ci=0.95):
-    """Protocol 14.1: resample relations, then facts within each drawn relation.
-
-    A plain per-fact bootstrap would understate the interval because the 21
-    relations are very unevenly sized and facts inside one relation are far from
-    independent.
-    """
-    fact_ids = [f for f in values if values[f] == values[f]]  # drop NaN
-    if not fact_ids:
-        return {"mean": float("nan"), "lo": float("nan"), "hi": float("nan"), "n": 0}
-    by_rel = {}
-    for f in fact_ids:
-        by_rel.setdefault(relation_of[f], []).append(f)
-    rels = sorted(by_rel)
-    arr = {r: np.array([values[f] for f in by_rel[r]], dtype=np.float64) for r in rels}
-    rng = np.random.default_rng(seed)
-    draws = np.empty(n_resamples, dtype=np.float64)
-    for b in range(n_resamples):
-        picked = rng.integers(0, len(rels), size=len(rels))
-        pool = []
-        for i in picked:
-            a = arr[rels[i]]
-            pool.append(a[rng.integers(0, len(a), size=len(a))])
-        draws[b] = np.concatenate(pool).mean()
-    lo, hi = np.percentile(draws, [(1 - ci) / 2 * 100, (1 + ci) / 2 * 100])
-    point = float(np.mean([values[f] for f in fact_ids]))
-    return {"mean": point, "lo": float(lo), "hi": float(hi), "n": len(fact_ids)}

ICLR dataset/metrics/states.py

@@ -1,157 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Per-layer family centroids -- the single input both ISS and KTS consume.
-
-Protocol 7.4-7.6 and 8.2 describe one preparation, then branch. Keeping it in
-one place means ISS and KTS cannot silently disagree about what a fact's
-representation under a condition family IS, which would make the joint
-interpretation table (protocol 12) meaningless.
-
-    z    = transport(h)                 raw: identity;  jlens: y = B h
-    zbar = z - mu_r - mu_t + mu         relation and family main effects removed
-    zt   = L2(PCA-whiten(zbar))         one transform per (model, layer)
-    v    = L2(mean of zt within a family)          -> [F, T, D], plus a mask
-"""
-import os, json
-
-import numpy as np
-import torch
-
-import mcommon as mc
-
-
-def l2n(X, eps=1e-12):
-    return X / X.norm(dim=-1, keepdim=True).clamp_min(eps)
-
-
-def whiten(Z, dim, shrinkage, eps):
-    """PCA whitening fitted once on the pooled matrix (protocol 7.5).
-
-    Fitting per condition family is forbidden: it would absorb exactly the
-    cross-condition differences these metrics exist to detect.
-    """
-    mu = Z.mean(0, keepdim=True)
-    Zc = Z - mu
-    n, d = Zc.shape
-    k = min(dim, d)
-    # d <= 5120 while n ~ 39k, so the d x d covariance route is far cheaper
-    # than an SVD of the tall matrix and numerically equivalent.
-    C = (Zc.T @ Zc).double() / max(n - 1, 1)
-    evals, evecs = torch.linalg.eigh(C)
-    evals = evals.flip(0)[:k].clamp_min(0).float()
-    evecs = evecs.flip(1)[:, :k].float()
-    lam = shrinkage * float(evals.mean())
-    return (Zc @ evecs) / torch.sqrt(evals + lam + eps)
-
-
-class StateLoader:
-    """Streams (layer -> family centroids) for one model."""
-
-    def __init__(self, model, transport="raw", coverage=None, device="auto",
-                 shuffle_seed=None):
-        C = mc.cfg()
-        self.C = C
-        self.model = model
-        self.transport = transport
-        # Protocol 18.1: with fact identity destroyed, ISS must collapse,
-        # KTS-ID must fall to chance and KTS-Geo to ~0. If they do not, the
-        # metric is measuring something other than the fact.
-        self.shuffle_seed = shuffle_seed
-        self.mode = coverage or C["headline_coverage"]
-        self.dev = ("cuda" if torch.cuda.is_available() else "cpu") \
-            if device == "auto" else device
-
-        self.hdir = mc.out("hidden", model)
-        self.meta = json.load(open(os.path.join(self.hdir, "index.json")))
-        if not self.meta.get("complete"):
-            raise SystemExit(f"{model}: hidden states incomplete; run extract_hidden.py")
-
-        self.families = C["main_families"]
-        fam_id = {t: i for i, t in enumerate(self.families)}
-        self.keep_facts = mc.eval_fact_set(self.mode)
-        self.fidx = {f: i for i, f in enumerate(self.keep_facts)}
-        self.rel_of = mc.fact_relation()
-
-        self.sel = np.array([i for i, f in enumerate(self.meta["fact_ids"])
-                             if f in self.fidx], dtype=np.int64)
-        self.fact_idx = torch.tensor(
-            [self.fidx[self.meta["fact_ids"][i]] for i in self.sel], device=self.dev)
-        self.fam_idx = torch.tensor(
-            [fam_id[self.meta["families"][i]] for i in self.sel], device=self.dev)
-
-        self.by_rel = {}
-        for f in self.keep_facts:
-            self.by_rel.setdefault(self.rel_of[f], []).append(self.fidx[f])
-        rel_pos = {r: i for i, r in enumerate(self.by_rel)}
-        self.rel_idx = torch.tensor(
-            [rel_pos[self.rel_of[self.meta["fact_ids"][i]]] for i in self.sel],
-            device=self.dev)
-        self.n_rel = len(self.by_rel)
-
-        self.window = self.meta["window"]
-        self.late = set(self.meta["late_window"])
-        self.B = None
-        if transport == "jlens":
-            self.B = {}
-            for l in self.window:
-                p = mc.out("jlens", model, f"L{l:03d}", "B.npy")
-                if not os.path.exists(p):
-                    raise SystemExit(
-                        f"{model} L{l}: no J-Lens factor at {p}. Run src/jlens.py "
-                        "first, or use --transport raw for the ablation.")
-                self.B[l] = torch.from_numpy(np.load(p)).to(self.dev).float()
-
-    @property
-    def n_facts(self):
-        return len(self.keep_facts)
-
-    def centroids(self, layer):
-        """-> V [F, T, D] (zero where absent), mask [F, T]."""
-        icfg = self.C["iss"]
-        eps = float(icfg["eps"])
-        H = np.load(os.path.join(self.hdir, f"L{layer:03d}.npy"), mmap_mode="r")
-        Z = torch.from_numpy(np.ascontiguousarray(H[self.sel])).to(self.dev).float()
-        if self.B is not None:
-            Z = Z @ self.B[layer].T                # y = B h (J-Lens spec 6.4)
-
-        # ---- protocol 7.4 double residualisation
-        mu = Z.mean(0, keepdim=True)
-        D = Z.shape[1]
-        mu_r = torch.zeros(self.n_rel, D, device=self.dev)
-        cr = torch.zeros(self.n_rel, device=self.dev)
-        mu_r.index_add_(0, self.rel_idx, Z)
-        cr.index_add_(0, self.rel_idx, torch.ones_like(self.rel_idx, dtype=torch.float))
-        mu_r /= cr.clamp_min(1).unsqueeze(-1)
-        mu_t = torch.zeros(len(self.families), D, device=self.dev)
-        ct = torch.zeros(len(self.families), device=self.dev)
-        mu_t.index_add_(0, self.fam_idx, Z)
-        ct.index_add_(0, self.fam_idx, torch.ones_like(self.fam_idx, dtype=torch.float))
-        mu_t /= ct.clamp_min(1).unsqueeze(-1)
-        Z = Z - mu_r[self.rel_idx] - mu_t[self.fam_idx] + mu
-
-        Z = l2n(whiten(Z, icfg["pca_dim"], icfg["shrinkage"], eps))
-
-        # ---- protocol 7.6 family centroid: average inside the family FIRST, so
-        # paraphrase (10,053 queries) cannot outweigh anchor (2,592) in one fact
-        F, T, Dn = self.n_facts, len(self.families), Z.shape[1]
-        V = torch.zeros(F, T, Dn, device=self.dev)
-        cnt = torch.zeros(F, T, device=self.dev)
-        flat = self.fact_idx * T + self.fam_idx
-        V.view(-1, Dn).index_add_(0, flat, Z)
-        cnt.view(-1).index_add_(0, flat, torch.ones_like(flat, dtype=torch.float))
-        mask = cnt > 0
-        V = V / cnt.clamp_min(1).unsqueeze(-1)
-        V = l2n(V) * mask.unsqueeze(-1)
-
-        if self.shuffle_seed is not None:
-            # Permute the fact axis INDEPENDENTLY per family, and permute within
-            # a relation so the shuffled control keeps the same relation
-            # composition -- otherwise a drop could just mean facts got matched
-            # against a different relation, which is not the null being tested.
-            g = torch.Generator().manual_seed(self.shuffle_seed + 1000 * layer)
-            for t in range(T):
-                for members in self.by_rel.values():
-                    idx = torch.tensor(members)
-                    perm = idx[torch.randperm(len(members), generator=g)]
-                    V[idx, t] = V[perm.to(V.device), t].clone()
-                    mask[idx, t] = mask[perm.to(mask.device), t].clone()
-        return V, mask

ICLR dataset/protocol/README (3).md

@@ -1,68 +0,0 @@
-# ICLR27 — Knowledge Fragility & Representational Instability
-
-研究主线：**canonical benchmark 判定"模型已知"的知识，在等价检索条件下并不稳定**——
-- **Finding 1（行为层）**：换等价问法就大面积答错 → *same answer ≠ same knowledge*。
-- **Finding 2（机理层）**：即使都答对，内部 SAE 表征也只部分对齐 → *same answer ≠ same internal representation*，且不随模型规模缓解。
-
-环境：`source /scratch/rds-fei-rsfm-rw/cshi0459/mllm_dangerous/mllm_dangerous/plus_env/bin/activate`；`export HF_HOME=/scratch/rds-fei-rsfm-rw/cshi0459/hf_cache`；2×H200，GPU 步骤设 `CUDA_VISIBLE_DEVICES`。
-7 个模型在 `Model/`：Gemma-2-2B-it, Gemma-2-9B-it, Llama-3.1-8B, Mistral-7B-v0.3, Qwen2.5-7B/14B/32B（Qwen 三个用于 scaling）。
-
----
-
-## 全链路（按依赖顺序）
-
-### 0. 原始数据集 → 统一三元组  → `dataset/`
-- 4 个来源：`counterfact/`(azhx/counterfact ROME)、`lama/`(官方LAMA probe)、`trex/`(relbert/t_rex)、`wikidata5m/`(Alphonse7/Wikidata5M-KG)。
-- 统一成 `{subject,relation,object}`：`dataset/triples/*.jsonl`（脚本 `dataset/to_triples.py`）。细节见 `dataset/triples/README.md`。
-
-### 1. Consensus 过滤 → Global-Known Set  → `dataset/filter/`
-- 每条知识构 canonical cloze prompt → 5 模型(2B/9B/Qwen7B/Mistral/Llama)各跑 cloze **首-token argmax** 判对 → **取交集**。
-- 脚本：`build_prompts.py → filter_run.py(×5, run_all.sh) → combine.py`。
-- **正式集**：`dataset/filter/global_known_clean.jsonl` —— **7729 条**（只保留 counterfact+lama_trex；conceptnet/googlere 因 first-token argmax 过松被弃，见下"口径"）。
-
-### 2. 五类扰动评测集  → `eval_dataset/`
-- `base.jsonl`(7729 知识本体：kid/subject/relation/object/aliases/subject_aliases/template) + 5 个 query 文件：
-  `queryA_canonical`(表层改写) `queryB_paraphrase`(格式变化) `queryC_reverse`(反向) `queryD_context`(干扰) `queryE_multilingual`(zh/fr/es/de/ru)。
-- 生成：`code/05_build_eval_dataset.py` + `code/rel_templates.py`（手写关系模板库，可复现无LLM）。字段/覆盖/限制见 `eval_dataset/README.md`。
-
-### 3. Finding 1 — 行为脆弱性  → `eval_dataset/results/`
-- 扁平 prompt 表(`eval_build_prompts.py`) → 各模型贪婪生成+别名宽松匹配判对(`eval_run.py`) → 汇总(`eval_report.py`)。
-- 评测口径映射：**Canonical=base cloze 基线**、Paraphrase=A、Reverse=C、Context=D、Multilingual=E、(Format=B 额外)。
-- **结果(clean sources, 7模型均值)**：Canonical 0.97 → Paraphrase 0.76 / Format 0.67 / Context 0.57 / Reverse 0.54 / Multilingual 0.41。条件化(只看已知)仍失败 23–59%。
-- 图：`eval_dataset/results/figures/fig_fragility_heatmap.{png,pdf}`（7×6 热图，红→灰→蓝，Times 字体）。完整结论 `eval_dataset/results/FINDINGS.md`。
-
-### 4. Finding 2 — 表征不稳定性 (SAE / nKSS)  → `code/sae/` + `sae/`
-- **每层一个独立 TopK-SAE** 重构 resid_post：d_sae=8×d_model, K_train=64, K_eval=50, 50M tokens **C4**(不碰评估query, token流带断线重连)。MSE无L1, decoder列单位化, per-layer RMS归一化。
-- 流程(每模型)：`train_saes.py`(显存用 layer_chunk 分块；经验 14B chunk12/bs16、32B chunk8/bs16，chunk给大会在Adam step OOM) → `eval_extract.py`(全层hook取 answer前一位token的Top-50 features, SAE以bf16载入) → `compute_kss.py` → `fig_kss_curve.py`。驱动 `run_kss.sh`。
-- **nKSS 定义**(每层每扰动)：对 canonical 与扰动C 都答对的事实，取各层 SAE Top-50 稀疏向量算 **cosine**；S_same(同事实)/S_rel(同关系不同事实,对照)/S_rand(随机)；**nKSS=(S_same−S_rand)/(1−S_rand)**(1=内部完全一致,0=与随机无异)。
-- **结果(7模型完成)**：(1)peak 一致落在 **late layers(78–94%深度)**,非全层均匀;(2)**peak nKSS 仅 0.09–0.68 远低于1.0**;(3)reverse/multilingual 内部最不稳(对应行为掉点最狠);Gemma系最稳,Llama最不稳(reverse 0.09)。Qwen 7B→14B→32B paraphrase 0.48→0.43→0.43,**不随规模提升**。
-- 图：`sae/fig_kss_summary.{png,pdf}`（(a)归一化深度曲线 (b)peak nKSS热图）；单模型曲线 `sae/<model>/fig_kss_curve_<model>.png`。完整 `sae/FINDINGS.md`。
-- 存储：`sae/<model>/sae_layer_NN.pt`(SAE权重) / `features.npz`(Top-50特征) / `kss_<model>.json`。
-
----
-
-## 关键口径与坑（务必记住）
-- **clean sources = counterfact + lama_trex**。conceptnet/googlere(date_of_birth) 被弃：first-token argmax 对年份(“19xx”首token谁都对)和常识多答案太松,误纳模型其实不会的知识(canonical 仅 0.04/0.20)——本身是次级发现。
-- **Multilingual 行为分被低估**：模型常用查询语言作答,gold英文匹配不上(真实保持率更高)。
-- **Reverse 只看 well_posed**(capital类,object唯一确定subject);ill_posed一对多已排除(退化~0)。
-- **C4 streaming 不稳**：长跑会 httpx 断线,train_saes 已加自动重连;HF 下载也���中断需重试。
-- SAE 训练无中途 checkpoint,崩了要整模型重训;半成品 sae_layer 文件不完整需清掉。
-
----
-
-## 下一步：让 nKSS 量化更精准（设计已定，未实现）
-改 `compute_kss.py`，要点：
-1. **headline 用关系对照归一化** nKSS_rel=(S_same−S_rel)/(S_ceil−S_rel)，扣掉关系/格式通用特征。
-2. **加"天花板" S_ceil**(同事实两改写变体的相似度)做分母 → **跨模型同尺度可比**(否则不同SAE的cosine绝对值不可比)。
-3. **val/test split(按kid)**：val选peak band(±2层),test报告,给 **bootstrap CI**,不用全数据post-hoc max。
-4. **per-fact配对量 + Wilcoxon + 效应量**,看分布(是否双峰)。
-5. **辅助robustness**：Jaccard(Top-K id集合重叠) + K_eval敏感性 + **raw-residual对照**(不过SAE算同样nKSS,堵"SAE artifact"质疑)。
-> 一句话:在val选的peak band上,关系对照+天花板归一化的per-fact配对稳定性,test报均值+CI+检验;辅以Jaccard/raw-residual/K敏感性。可直接在已存 features.npz 上重算,不必重训SAE。
-
-## 候选后续方向
-- **机理↔行为因果链**(最强):逐事实关联 nKSS 与行为是否答对——内部稳的知识是否扰动下更不容易崩。
-- 论文主图(Finding1热图 + Finding2曲线组合)。
-- 提升SAE质量(更多token/调K)看nKSS绝对值。
-
-## Memory 索引(自动加载)
-`[[iclr27-triples]] [[iclr27-filtering]] [[iclr27-evl]] [[iclr27-fragility]] [[iclr27-sae-kss]] [[scratch-env]]`

ICLR dataset/protocol/README (4).md

@@ -1,216 +0,0 @@
-# `dataset3/` —— Fact Knowledge Stability Benchmark
-
-按 [`../dataset/fact_knowledge_stability_dataset_reconstruction.md`](../dataset/fact_knowledge_stability_dataset_reconstruction.md)
-从 `../dataset/` 的数据重建。**不改动 `../dataset/` 和 `../dataset2/`。**
-
-与 `dataset2` 的根本区别在方法论，不在数字：
-
-> **基准集是固定的 2,592 条，对所有模型相同。** `K_m` 只是每个模型的正确性**标签**，
-> 绝不用来从基准集里删事实（spec §2.1）。模型答错、一直答错、拒答、
-> 在不同条件下答不同答案——事实都留在集合里。
-
----
-
-## 目录
-
-```
-dataset3/
-├── configs/                     # 全部参数外置，脚本里不硬编码（spec §4.4, §18）
-│   ├── models.yaml              #   5 个过滤模型 + 评测模型 + 生成配置
-│   ├── relations.yaml           #   21 个基准关系 + 排除清单 + 两个开关
-│   ├── source_templates.yaml    #   原始来源、cloze 模板、别名资源
-│   └── eval_conditions.yaml     #   8 个条件的角色/目标槽/期望计数
-├── src/
-│   ├── common.py                    公共：配置/规范化/校验和/计数核对
-│   ├── build_candidate_known.py (I)   → candidate_known_8107.jsonl
-│   ├── enrich_facts.py         (II)   → enriched_facts_6180.jsonl
-│   ├── select_benchmark.py     (III)  → benchmark_facts_2592.jsonl
-│   ├── build_eval_bank.py      (IV)   → evaluation_queries_44418.jsonl
-│   ├── validate_facts.py              → validation_report.json  ← 硬门禁
-│   ├── build_stats.py                 → dataset_statistics.json
-│   ├── qualification_run.py    (V)    → qualification/<model>.jsonl   [GPU]
-│   ├── qualification_score.py  (V)    → known_labels.json
-│   ├── eval_run.py             (VI)   → evaluation/<model>.jsonl       [GPU]
-│   ├── eval_score.py           (VI)   → stability_report.json
-│   ├── filter_run.py                  阶段 I 首 token 过滤（重跑用）  [GPU]
-│   ├── scoring_full.py                五标签判分器
-│   ├── qual_templates.py              非基准关系的兜底问句
-│   └── test_scoring.py                31 条单元测试
-├── outputs/
-└── run_pipeline.sh              # build / gpu / score / report / all
-```
-
----
-
-## 六个阶段
-
-### I. 候选召回 → 8,107（spec §4）
-
-```
-1,783,541 cloze prompt
-   → 5 模型首 token argmax 取交集 → 10,601
-   → 丢弃 T-REx / Wikidata5M 子集，补 PopQA 378 → 8,107
-```
-
-**GPU 未重跑。** 那 1,783,541 × 5 次前向的逐条判定向量已存于
-`dataset/filter/correct_<model>.npy`。[build_candidate_known.py](src/build_candidate_known.py)
-重新读取 prompt 表、**重新求交集**、重新施加来源丢弃规则，并把每个输入文件的
-校验和写进 `stage1_report.json`——数字是**验证出来的**，不是照抄。
-另外与 `dataset/filter/global_known_clean.jsonl` 做集合相等性核对。
-要从零重跑推理用 `src/filter_run.py`。
-
-### II. 事实增强 → 6,180（spec §5）
-
-- **实体感知分组**：优先用实体 ID，无 ID 才退回规范化文本；**跨来源合并**
-  （1,036 组同时出现在 CounterFact 和 LAMA-TREx）。8,107 行 → 6,185 组
-- **函数型冲突丢弃 5 条**：同名不同人（两个 "Michael Vincent" 生于 1964/1976）问题本身无解。
-  判据严格——**缺实体 ID 不算"同一实体"的证据**，所有成员必须都有 ID 且一致才保留
-- **别名扩展**：对别名资源做**单次过滤扫描**（spec §5.3），不全量载入
-- **挂 canonical 问句**，与评测扰动模板严格分离（spec §16）
-
-### III. 基准选择 → 2,592 / 21 关系（spec §6）
-
-```
-6,180 → core 来源（CounterFact + LAMA-TREx + PopQA）→ 3,705
-      → 函数型（单值）关系 → 2,592
-```
-
-### IV. 查询库 → 44,416（spec §8–§12）
-
-| 条件 | 查询 | 事实 | 角色 |
-|---|---:|---:|---|
-| anchor | 2,592 | 2,592 | main |
-| multilingual | 12,010 | 2,402 | main |
-| paraphrase | 10,053 | 2,592 | main |
-| format | 7,776 | 2,592 | main |
-| context | **6,829** | 2,591 | main |
-| reverse | 634 | 253 | **结构分析，单独报** |
-| recognition | 3,412 | 2,585 | 诊断 |
-| reverse_illposed | 1,110 | 1,110 | 诊断 |
-| **合计** | **44,416** | | main forward **39,260** |
-
-每条查询自带 `use_for_main_forward` / `use_for_reverse_analysis` /
-`use_for_recognition_analysis` 三个布尔量，**由 `eval_conditions.yaml` 派生**，
-下游聚合不需要硬编码哪个条件进哪个平均。校验器会检查每行的布尔量与注册表一致。
-
-### V. Anchor 资格认证 → `K_m` 标签（spec §7）⬜ 待跑
-
-纯补全 prompt（base 与 instruct 用**完全相同**的字符串，无 chat template）、
-贪婪解码 24 token、无候选无 few-shot。判分在 CPU，**五标签**：
-
-`correct` / `incorrect` / `ambiguous` / `abstain` / `unparseable`
-
-输出 `known_labels.json`：`{fact_id: {model: label}}`，覆盖全部 2,592 × 全部模型。
-
-### VI. 扰动评测 → 稳定性 ⬜ 待跑
-
-[eval_run.py](src/eval_run.py) 跑全部 44,416 条查询，
-**解码配置与 anchor 完全一致**（同一份 `configs/models.yaml:generation`）——
-否则 `max_new_tokens` 或 chat template 的差异会被误读成稳定性效应。
-anchor 也一起重跑，让所有条件走同一条代码路径。
-
-[eval_score.py](src/eval_score.py) 在 CPU 判分并出报表，三条规则写死在代码里而不是留给读者：
-
-1. **按查询自带的布尔量分组** —— `recognition` 和 `reverse_illposed` 永不进主平均，
-   `reverse` 因为换了目标槽而单独报（spec §2.3）
-2. **两个分母并排报**：`fixed`（固定 2,592，spec §2.1）与
-   `anchored`（限定在该模型的 `K_m` 内，即条件化保持率）
-3. **每个数字按 `answer_in_subject_surface` 再拆一次**（`·real` / `·copy`），
-   因为 28.9% 的事实靠复制就能答对、天然接近满分（见 F1）
-
-主指标 macro = paraphrase / format / context / multilingual 四者均值：
-anchor 是基线不计入，reverse 换了槽不计入，两个诊断条件不计入。
-
----
-
-## 运行
-
-```bash
-cd /scratch/rds-fei-rsfm-rw/cshi0459/ICLR27/dataset3
-bash run_pipeline.sh build     # 阶段 I-IV + 校验 + 统计，CPU 约 1 分钟（已跑完）
-bash run_pipeline.sh gpu       # 阶段 V+VI 生成，每个模型只加载一次权重
-bash run_pipeline.sh score     # 阶段 V 判分 → K_m 标签
-bash run_pipeline.sh report    # 阶段 VI 判分 → stability_report.json
-```
-
-`gpu` 把 anchor 和扰动两趟生成合在一起跑，权重只载入一次。
-两个生成阶段都幂等：anchor 已存在会跳过，`eval_run.py --resume` 会跳过已完成的查询。
-
-**顺序要求**：`score` 必须在 `report` 之前跑，否则没有 `known_labels.json`，
-`anchored` 那一列会缺失（脚本会警告并只报 `fixed`）。
-
----
-
-## 当前状态
-
-| 阶段 | 状态 |
-|---|---|
-| I 候选召回 | ✅ 8,107，全部计数命中 |
-| II 事实增强 | ✅ 6,180，6,185 组 / 5 冲突 / 1,771 合并 / 1,036 跨来源，全中 |
-| III 基准选择 | ✅ 2,592 / 21 关系，全中 |
-| IV 查询库 | ✅ 44,416（见差异 D1） |
-| 校验 | ✅ **0 hard errors** |
-| 单元测试 | ✅ **31/31** |
-| V 资格认证 | ⬜ 待跑（判分逻辑已用合成数据演练通过） |
-| VI 扰动评测 | ⬜ 待跑（运行器 + 报表已用合成数据演练通过） |
-
----
-
-## 与 spec 的差异（完整版见 [outputs/reconstruction_differences.md](outputs/reconstruction_differences.md)）
-
-除一处外全部精确复现。
-
-**D1 — context 6,831 → 6,829，总计 44,418 → 44,416。**
-旧数据里有 2 条 context 查询的干扰实体字面包含 gold：
-`"...confuse States Reorganisation Act with **Indian** Act..."` 而 gold 是 `India`。
-违反 spec §9.4 与 §13.9。按 spec §10「发现既有缺陷可改数」处理：
-在建库时加**规则化守卫**（主语提及剔除后 gold 仍出现即丢弃），不是硬编码例外。
-
-**C1 — spec §6.2 与要求的规模自相矛盾。**
-§6.2 点名 `developer of` / `manufacturer of` 不适合，但这两个关系共 **846 条**，
-去掉只剩 1,746 条 / 19 关系，达不到 §15 验收要求的 2,592 / 21。
-处理：保留并打 `spec_6_2_flag`，`relations.yaml` 提供 `drop_spec_6_2_flagged` 开关
-可一键产出 1,746 条的合规变体。
-
-**F1 — 28.9% 的基准事实可以靠复制字符串答对。**
-2,592 条里有 **750 条** object 字面包含在 subject 名字里：
-
-```
-Airbus A318  → manufacturer  Airbus      (该关系 87.8% 命中)
-Adobe Acrobat → developer    Adobe        (49.1%)
-Amazon Music  → owned by     Amazon       (58.4%)
-```
-
-其中 586 条来自 manufacturer 和 developer——**独立印证了 C1**。
-这类事实"稳定"的原因与知识无关，会抬高所有保持率、削弱要研究的效应。
-按 spec §16 不删，打 `answer_in_subject_surface` 标记，事实和查询两级都带。
-`qualification_score.py` 已经**默认分开报**这两个子集的准确率。
-
-**F2 — 8,107 里有 808 条完全重复的三元组**（唯一四元组只有 7,299）。分组阶段自然吸收，仅记录。
-
-**N1 — Stage I 未重跑 GPU**（见上）。
-**N2 — `capital_of` 方向未归一化**：spec §2.2 要求单一方向，但归一化会改变规模，故保留
-`direction: inverse` + `inverse_of: capital` 显式标注，开关在 `relations.yaml`。
-
----
-
-## 两个必须记住的口径
-
-1. **分母永远是 2,592。** `K_m` 是标签不是筛子。加模型、换模型都不改任何已算出的数。
-2. **reverse 不进 main forward 平均。** 它换了目标槽（object → subject），
-   spec §2.3 要求单独报。`recognition` 和 `reverse_illposed` 同理，且校验器有硬检查。
-
----
-
-## 报告用描述（spec §17）
-
-> We first use five-model first-token consensus to retrieve high-probability
-> factual candidates from large-scale knowledge resources. We then merge
-> duplicate facts, expand entity aliases, construct independent canonical
-> questions, remove ambiguous and multi-valued relations, and obtain a fixed
-> benchmark of 2,592 facts across 21 relations. Model-specific open-ended anchor
-> generation provides correctness labels but does not alter the benchmark
-> denominator. Based on the fixed fact set, we construct 44,416 queries covering
-> anchor, paraphrastic, format, contextual, cross-lingual, reverse, and
-> recognition conditions, while isolating ill-posed reverse queries as a
-> separate diagnostic set.

ICLR dataset/protocol/bcs_bes_iss_kts_evaluation_protocol (1).md

@@ -1,1604 +0,0 @@
-# BCS、BES、ISS 与 KTS 评测规范
-
-## 0. 目的
-
-本规范用于在固定事实知识数据集上评测大语言模型的：
-
-1. **外部行为一致性**；
-2. **内部事实状态稳定性**；
-3. **整体知识拓扑稳定性**。
-
-最终报告四个核心指标：
-
-\[
-\boxed{
-\mathrm{BCS},\quad
-\mathrm{BES},\quad
-\mathrm{ISS},\quad
-\mathrm{KTS}
-}
-\]
-
-其中：
-
-| 指标 | 全称 | 分析层级 | 核心问题 |
-|---|---|---|---|
-| BCS | Behavioral Consistency Score | 单事实、外部行为 | 不同检索条件下是否主要表达同一个答案？ |
-| BES | Behavioral Entropy Stability | 单事实、外部行为 | 回答分布是否集中，还是分散到多个答案？ |
-| ISS | Internal State Stability | 单事实、内部表示 | 同一事实跨条件是否形成一致且可区分的内部状态？ |
-| KTS | Knowledge Topology Stability | 数据集、内部空间 | 不同条件下事实身份与整体知识几何是否保持？ |
-
-本规范默认使用固定主事实集：
-
-\[
-\mathcal D=\{f_1,\ldots,f_N\},\qquad N=2,592.
-\]
-
-所有被测模型使用完全相同的事实和 query bank。模型在 anchor 条件下是否回答正确，只作为标签，不改变评测分母。
-
----
-
-# 1. 评测条件
-
-## 1.1 主前向检索条件
-
-以下条件保持检索目标为：
-
-\[
-(s,r)\rightarrow o.
-\]
-
-记主条件集合为：
-
-\[
-\mathcal T=
-\{
-\text{anchor},
-\text{paraphrase},
-\text{format},
-\text{context},
-\text{multilingual}
-\}.
-\]
-
-这些条件进入 BCS、BES、ISS 和 KTS 的主要计算。
-
-## 1.2 独立诊断条件
-
-以下条件不混入主指标：
-
-- `recognition`：正确答案已经出现在候选中，属于辅助识别；
-- `reverse`：检索目标从 object 改为 subject，单独报告 structural retrieval；
-- `reverse_illposed`：反向映射不唯一，只用于数据诊断。
-
-## 1.3 覆盖不完整时的处理
-
-当前数据中：
-
-- anchor：覆盖 2,592 条事实；
-- paraphrase：覆盖 2,592 条事实；
-- format：覆盖 2,592 条事实；
-- context：覆盖 2,591 条事实；
-- multilingual：覆盖 2,402 条事实。
-
-推荐优先补齐缺失条件。
-
-在未补齐前，应同时报告：
-
-### Complete-family 主结果
-
-仅使用具备全部五个主条件的事实集合：
-
-\[
-\mathcal D_{\cap}
-=
-\bigcap_{t\in\mathcal T}\mathcal D_t.
-\]
-
-这是最严格、最可比的主结果。
-
-### Full-set 补充结果
-
-对每条事实使用其实际存在的条件集合：
-
-\[
-\mathcal T_f
-=
-\{t\in\mathcal T:f\in\mathcal D_t\}.
-\]
-
-所有平均都按可用 condition family 等权计算，并报告每个指标的有效样本数。
-
-不能为缺失条件伪造零分，也不能把不同模型的有效事实集设为不同集合。
-
----
-
-# 2. 必要输入
-
-## 2.1 Fact 文件
-
-每条事实至少包含：
-
-```json
-{
-  "fact_id": "fact_000001",
-  "subject": "France",
-  "relation": "capital",
-  "object": "Paris",
-  "gold_aliases": ["Paris", "City of Paris"],
-  "answer_type": "city",
-  "answer_granularity": "entity"
-}
-```
-
-## 2.2 Query 文件
-
-每条 query 至少包含：
-
-```json
-{
-  "query_id": "query_00000001",
-  "fact_id": "fact_000001",
-  "condition_family": "paraphrase",
-  "variant_id": "para_02",
-  "language": "en",
-  "query": "Which city serves as the capital of France?",
-  "target_slot": "object",
-  "use_for_main_forward": true
-}
-```
-
-## 2.3 模型输出文件
-
-```json
-{
-  "model": "model_name",
-  "query_id": "query_00000001",
-  "fact_id": "fact_000001",
-  "condition_family": "paraphrase",
-  "raw_response": "The answer is Paris.",
-  "generation_config": {
-    "do_sample": false,
-    "temperature": 0,
-    "max_new_tokens": 24
-  }
-}
-```
-
-## 2.4 内部表示文件
-
-ISS 和 KTS 需要在模型尚未生成第一个答案 token 时，提取问题末位位置的 residual state：
-
-```json
-{
-  "model": "model_name",
-  "query_id": "query_00000001",
-  "fact_id": "fact_000001",
-  "condition_family": "paraphrase",
-  "layer": 16,
-  "position": "query_end",
-  "hidden_state_path": "..."
-}
-```
-
-必须保证所有 query 使用同一种位置定义：
-
-> 输入 prompt 的最后一个有效 token，即模型读完问题但尚未开始生成答案的位置。
-
----
-
-# 3. AI Judge 输出协议
-
-BCS 和 BES 不直接比较原始字符串，而基于 AI Judge 得到的语义答案 cluster。
-
-整个过程分为两步。
-
-## 3.1 Reference-blind 答案抽取与聚类
-
-Judge 不看 gold answer，只完成：
-
-1. 提取回答最终主张的核心答案；
-2. 忽略句式、语言、标点和解释性文字；
-3. 将语义等价答案归为同一 cluster；
-4. 标记拒答、多答案和无法解析输出。
-
-例如：
-
-```text
-Paris
-The answer is Paris.
-Paris, France.
-巴黎
-```
-
-应归入同一个语义 cluster。
-
-建议特殊 cluster：
-
-- `ABSTAIN`：拒答或明确表示不知道；
-- `MULTIPLE`：给出多个冲突答案且未选择；
-- `UNPARSEABLE`：无法提取明确答案；
-- 具��实体或命题 cluster，如 `ENTITY_Q90` 或 `SEMANTIC_PARIS`。
-
-Judge 输出：
-
-```json
-{
-  "query_id": "query_00000001",
-  "fact_id": "fact_000001",
-  "cluster_id": "ENTITY_Q90",
-  "canonical_meaning": "Paris",
-  "status": "ANSWER",
-  "confidence": 0.98
-}
-```
-
-同一事实的所有主条件输出应一次性或全局一致地聚类，避免两两判断产生非传递关系。
-
-## 3.2 Reference-aware 正确性判断
-
-第二步再向 Judge 提供：
-
-- gold answer；
-- accepted aliases；
-- answer type；
-- answer granularity。
-
-对每个语义 cluster 标记：
-
-- `CORRECT`；
-- `INCORRECT`；
-- `ABSTAIN`；
-- `AMBIGUOUS`；
-- `REVIEW_REQUIRED`。
-
-该步骤用于区分 Stable Correct 和 Stable Wrong，但不参与答案 cluster 的形成。
-
----
-
-# 4. BCS：Behavioral Consistency Score
-
-## 4.1 为什么需要 family-balanced 计算
-
-不同 condition family 的 query 数量差异很大。例如：
-
-- paraphrase 可能有 3–5 个版本；
-- multilingual 可能有多个语言版本；
-- anchor 通常只有 1 条。
-
-如果直接按全部 query 计数，query 更多的 family 会支配结果。
-
-因此必须先在每个 family 内计算答案分布，再对 family 等权聚合。
-
-## 4.2 Family 内答案分布
-
-设事实 \(f\) 在 family \(t\) 下的 query 集为：
-
-\[
-Q_{f,t}.
-\]
-
-AI Judge 给 query \(q\) 分配语义 cluster：
-
-\[
-\kappa_{m,f,q}.
-\]
-
-对于答案 cluster \(a\)，定义：
-
-\[
-p_{m,f,t}(a)
-=
-\frac{1}{|Q_{f,t}|}
-\sum_{q\in Q_{f,t}}
-\mathbb I[
-\kappa_{m,f,q}=a
-].
-\]
-
-每个 family 的总概率满足：
-
-\[
-\sum_a p_{m,f,t}(a)=1.
-\]
-
-## 4.3 跨 family 等权聚合
-
-对事实 \(f\) 的有效主条件集合 \(\mathcal T_f\)，定义：
-
-\[
-p_{m,f}(a)
-=
-\frac{1}{|\mathcal T_f|}
-\sum_{t\in\mathcal T_f}
-p_{m,f,t}(a).
-\]
-
-这样每个 condition family 权重相同，不受该 family 中 query 数量影响。
-
-## 4.4 BCS 定义
-
-\[
-\boxed{
-\mathrm{BCS}_{m,f}
-=
-\max_a p_{m,f}(a)
-}
-\]
-
-取最大概率的 cluster：
-
-\[
-a^*_{m,f}
-=
-\arg\max_a p_{m,f}(a).
-\]
-
-解释：
-
-- \(\mathrm{BCS}=1\)：所有有效条件都只支持同一个语义答案；
-- \(\mathrm{BCS}=0.8\)：主要答案获得 80% 的 family-balanced 概率；
-- BCS 较低：输出分散到多个答案。
-
-BCS 不判断主答案是否正确。
-
-例如，gold 是 `Canberra`，但所有条件都回答 `Sydney`：
-
-\[
-\mathrm{BCS}=1.
-\]
-
-这是高度稳定但错误的行为。
-
-## 4.5 模型级 BCS
-
-\[
-\boxed{
-\mathrm{BCS}_m
-=
-\frac{1}{|\mathcal D_{\mathrm{eval}}|}
-\sum_{f\in\mathcal D_{\mathrm{eval}}}
-\mathrm{BCS}_{m,f}
-}
-\]
-
-其中：
-
-- 主结果使用 \(\mathcal D_{\cap}\)；
-- 补充结果可使用完整可用集合。
-
----
-
-# 5. BES：Behavioral Entropy Stability
-
-BCS 只关注最大答案 cluster，可能忽略剩余概率如何分布。
-
-例如以下两种情况的 BCS 都是 0.6：
-
-```text
-A: 0.6, B: 0.4
-```
-
-和：
-
-```text
-A: 0.6, B: 0.1, C: 0.1, D: 0.1, E: 0.1
-```
-
-第二种回答明显更加分散，因此需要 BES。
-
-## 5.1 答案熵
-
-基于 family-balanced 分布 \(p_{m,f}(a)\)，定义：
-
-\[
-H_{m,f}
-=
--\sum_{a:p_{m,f}(a)>0}
-p_{m,f}(a)\log p_{m,f}(a).
-\]
-
-设实际观察到的非零答案 cluster 数为：
-
-\[
-A_{m,f}
-=
-\left|
-\{a:p_{m,f}(a)>0\}
-\right|.
-\]
-
-## 5.2 BES 定义
-
-当 \(A_{m,f}=1\) 时：
-
-\[
-\mathrm{BES}_{m,f}=1.
-\]
-
-当 \(A_{m,f}>1\) 时：
-
-\[
-\boxed{
-\mathrm{BES}_{m,f}
-=
-1-
-\frac{H_{m,f}}{\log A_{m,f}}
-}
-\]
-
-解释：
-
-- \(\mathrm{BES}=1\)：回答完全集中于一个 cluster；
-- \(\mathrm{BES}=0\)：回答在所有已观察 cluster 上均匀分布；
-- 值越高，回答分布越集中。
-
-BCS 和 BES 的区别：
-
-- BCS 衡量最大 cluster 的占比；
-- BES 衡量完整答案分布的集中程度。
-
-建议将 BCS 作为主外部稳定性指标，BES 作为补充指标。
-
-## 5.3 模型级 BES
-
-\[
-\boxed{
-\mathrm{BES}_m
-=
-\frac{1}{|\mathcal D_{\mathrm{eval}}|}
-\sum_{f\in\mathcal D_{\mathrm{eval}}}
-\mathrm{BES}_{m,f}
-}
-\]
-
----
-
-# 6. 外部行为类型
-
-设置预注册的行为稳定阈值：
-
-\[
-\tau_B=0.8.
-\]
-
-根据主答案 cluster \(a^*_{m,f}\) 的正确性，将事实划分为：
-
-## 6.1 Stable Correct
-
-\[
-\mathrm{BCS}_{m,f}\ge \tau_B
-\]
-
-且：
-
-\[
-a^*_{m,f}\text{ 被 Judge 标记为 CORRECT}.
-\]
-
-## 6.2 Stable Wrong
-
-\[
-\mathrm{BCS}_{m,f}\ge \tau_B
-\]
-
-且主 cluster 是明确的错误答案。
-
-## 6.3 Stable Abstention
-
-\[
-\mathrm{BCS}_{m,f}\ge \tau_B
-\]
-
-且：
-
-\[
-a^*_{m,f}=\mathrm{ABSTAIN}.
-\]
-
-## 6.4 Unstable
-
-\[
-\mathrm{BCS}_{m,f}<\tau_B.
-\]
-
-建议额外做阈值敏感性分析：
-
-\[
-\tau_B\in\{0.7,0.8,0.9\}.
-\]
-
-模型级比例：
-
-\[
-\mathrm{SCR}_m
-=
-\frac{\#\text{Stable Correct}}{|\mathcal D_{\mathrm{eval}}|},
-\]
-
-\[
-\mathrm{SWR}_m
-=
-\frac{\#\text{Stable Wrong}}{|\mathcal D_{\mathrm{eval}}|},
-\]
-
-\[
-\mathrm{SAR}_m
-=
-\frac{\#\text{Stable Abstention}}{|\mathcal D_{\mathrm{eval}}|},
-\]
-
-\[
-\mathrm{UR}_m
-=
-\frac{\#\text{Unstable}}{|\mathcal D_{\mathrm{eval}}|}.
-\]
-
-四者应满足：
-
-\[
-\mathrm{SCR}_m+
-\mathrm{SWR}_m+
-\mathrm{SAR}_m+
-\mathrm{UR}_m
-=1.
-\]
-
----
-
-# 7. ISS：Internal State Stability
-
-## 7.1 测量目标
-
-ISS 衡量：
-
-> 同一事实在不同主检索条件下，是否形成一致且具有事实区分性的内部状态。
-
-ISS 不依赖模型最终答案是否正确，也不依赖 gold answer 是单 token 还是多 token。
-
-## 7.2 Query-end hidden state
-
-对于模型 \(m\)、事实 \(f\)、query \(q\) 和层 \(\ell\)，提取：
-
-\[
-h^\ell_{m,f,q}\in\mathbb R^{d_m}.
-\]
-
-位置固定为 query 最后一个有效输入 token。
-
-## 7.3 J-Lens Jacobian transport
-
-对每一层估计平均 Jacobian transport：
-
-\[
-J^\ell_m
-=
-\mathbb E_x
-\left[
-\frac{\partial h^L_m}{\partial h^\ell_m}
-\right].
-\]
-
-将第 \(\ell\) 层状态运输到 final-layer residual basis：
-
-\[
-\boxed{
-z^\ell_{m,f,q}
-=
-J^\ell_m h^\ell_{m,f,q}
-}
-\]
-
-这里只使用运输后的 hidden representation，不乘 unembedding matrix，因此不进入 vocabulary space。
-
-如果暂时无法实现 Jacobian transport，可以用 raw hidden state 计算一个 `Raw-ISS` 作为消融，但主指标应使用 transported state。
-
-## 7.4 去除 relation 和 condition family 主效应
-
-对每个模型和层计算：
-
-\[
-\mu^\ell_m
-=
-\mathbb E_{f,q}[z^\ell_{m,f,q}],
-\]
-
-\[
-\mu^\ell_{m,r}
-=
-\mathbb E_{f,q:r_f=r}[z^\ell_{m,f,q}],
-\]
-
-\[
-\mu^\ell_{m,t}
-=
-\mathbb E_{f,q:t(q)=t}[z^\ell_{m,f,q}].
-\]
-
-双重残差化：
-
-\[
-\bar z^\ell_{m,f,q}
-=
-z^\ell_{m,f,q}
--
-\mu^\ell_{m,r_f}
--
-\mu^\ell_{m,t(q)}
-+
-\mu^\ell_m.
-\]
-
-该步骤用于减少：
-
-- relation 类型共有方向；
-- query 格式共有方向；
-- 语言 family 共有方向；
-- residual stream 公共均值。
-
-## 7.5 正则化白化
-
-估计协方差：
-
-\[
-\Sigma^\ell_m
-=
-\operatorname{Cov}
-\left(
-\bar z^\ell_{m,f,q}
-\right).
-\]
-
-定义：
-
-\[
-\tilde z^\ell_{m,f,q}
-=
-\left(
-\Sigma^\ell_m+\lambda I
-\right)^{-1/2}
-\bar z^\ell_{m,f,q}.
-\]
-
-实践建议：
-
-- 使用 shrinkage covariance；
-- 或使用 PCA whitening；
-- PCA 维度固定为 \(\min(512,d_m)\)；
-- 所有 query 使用同一个模型、同一层的变换；
-- 不允许为不同 condition family 单独拟合白化矩阵。
-
-随后进行 L2 归一化：
-
-\[
-\hat z^\ell_{m,f,q}
-=
-\frac{\tilde z^\ell_{m,f,q}}
-{\|\tilde z^\ell_{m,f,q}\|_2+\epsilon}.
-\]
-
-## 7.6 Family centroid
-
-一个 family 内可能有多个 query。为了避免 query 数量多的 family 获得更高权重，先计算 family centroid：
-
-\[
-v^\ell_{m,f,t}
-=
-\operatorname{Normalize}
-\left(
-\frac{1}{|Q_{f,t}|}
-\sum_{q\in Q_{f,t}}
-\hat z^\ell_{m,f,q}
-\right).
-\]
-
-每条事实在每个 condition family 下只保留一个表示。
-
-## 7.7 同事实跨 family 相似度
-
-设事实 \(f\) 的有效 family pair 集为：
-
-\[
-\mathcal P_f
-=
-\{(t,t'):t,t'\in\mathcal T_f,\ t<t'\}.
-\]
-
-定义正样本相似度：
-
-\[
-S^+_{m,f,\ell}
-=
-\frac{1}{|\mathcal P_f|}
-\sum_{(t,t')\in\mathcal P_f}
-\cos
-\left(
-v^\ell_{m,f,t},
-v^\ell_{m,f,t'}
-\right).
-\]
-
-## 7.8 同 relation 背景相似度
-
-为每个事实选择同 relation、不同事实的负样本集合：
-
-\[
-\mathcal N_f
-=
-\{g:g\neq f,\ r_g=r_f\}.
-\]
-
-对于每个 family pair，使用对称背景：
-
-\[
-B_{m,f,\ell}(t,t')
-=
-\frac{1}{2|\mathcal N_f|}
-\sum_{g\in\mathcal N_f}
-\left[
-\cos(v^\ell_{m,f,t},v^\ell_{m,g,t'})
-+
-\cos(v^\ell_{m,f,t'},v^\ell_{m,g,t})
-\right].
-\]
-
-再定义：
-
-\[
-S^-_{m,f,\ell}
-=
-\frac{1}{|\mathcal P_f|}
-\sum_{(t,t')\in\mathcal P_f}
-B_{m,f,\ell}(t,t').
-\]
-
-如果同 relation 事实过多，可以固定随机采样最多 100 个负事实，并对所有模型使用同一采样列表。
-
-## 7.9 ISS 定义
-
-\[
-\boxed{
-\mathrm{ISS}_{m,f,\ell}
-=
-\frac{
-S^+_{m,f,\ell}
--
-S^-_{m,f,\ell}
-}{
-1-S^-_{m,f,\ell}+\epsilon
-}
-}
-\]
-
-解释：
-
-- 接近 1：同一事实跨条件高度一致；
-- 接近 0：同一事实的相似性不高于同 relation 背景；
-- 小于 0：跨条件表示比其他事实背景还不一致。
-
-该值理论上可能小于 \(-1\)。统计分析应保留原始值；如果用于图表展示，可额外报告裁剪版本：
-
-\[
-\mathrm{ISS}^{\mathrm{clip}}
-=
-\operatorname{clip}(\mathrm{ISS},-1,1).
-\]
-
-不要用裁剪值替代原始统计值。
-
-## 7.10 跨层 ISS
-
-将相对层深定义为：
-
-\[
-d_\ell
-=
-\frac{\ell}{L_m-1}.
-\]
-
-预注册主分析窗口：
-
-\[
-\mathcal W_m
-=
-\{\ell:0.4\le d_\ell\le1.0\}.
-\]
-
-单事实 ISS：
-
-\[
-\boxed{
-\mathrm{ISS}_{m,f}
-=
-\frac{1}{|\mathcal W_m|}
-\sum_{\ell\in\mathcal W_m}
-\mathrm{ISS}_{m,f,\ell}
-}
-\]
-
-模型级 ISS：
-
-\[
-\boxed{
-\mathrm{ISS}_m
-=
-\frac{1}{|\mathcal D_{\mathrm{eval}}|}
-\sum_{f\in\mathcal D_{\mathrm{eval}}}
-\mathrm{ISS}_{m,f}
-}
-\]
-
-同时建议报告：
-
-### Peak ISS
-
-\[
-\mathrm{ISS}^{\mathrm{peak}}_{m,f}
-=
-\max_{\ell\in\mathcal W_m}
-\mathrm{ISS}_{m,f,\ell}.
-\]
-
-表示模型是否曾形成过一致事实状态。
-
-### Late ISS
-
-\[
-\mathrm{ISS}^{\mathrm{late}}_{m,f}
-=
-\frac{1}{|\mathcal W^{\mathrm{late}}_m|}
-\sum_{\ell:d_\ell\ge0.8}
-\mathrm{ISS}_{m,f,\ell}.
-\]
-
-表示一致状态是否保持到靠近输出的阶段。
-
----
-
-# 8. KTS：Knowledge Topology Stability
-
-## 8.1 测量目标
-
-KTS 衡量：
-
-> 不同 condition family 下，整个事实表示空间的相对几何和事实身份是否保持。
-
-KTS 不要求不同问法触发相同的计算路径。
-
-它允许：
-
-- 整体空间旋转；
-- 平移；
-- 各向同性缩放；
-- 不同语言使用不同内部实现。
-
-只要事实间相对结构和事实身份仍可保持，KTS 就可以较高。
-
-## 8.2 Condition-specific knowledge space
-
-对 condition family \(t\)、层 \(\ell\)，将所有有效事实的 family centroid 组成：
-
-\[
-V^\ell_{m,t}
-=
-\begin{bmatrix}
-v^\ell_{m,1,t}\\
-v^\ell_{m,2,t}\\
-\vdots\\
-v^\ell_{m,N_t,t}
-\end{bmatrix}.
-\]
-
-对 family pair \((t,t')\)，只使用共同覆盖事实：
-
-\[
-\mathcal D_{t,t'}
-=
-\mathcal D_t\cap\mathcal D_{t'}.
-\]
-
-不同模型必须使用完全相同的 \(\mathcal D_{t,t'}\)。
-
----
-
-# 9. KTS-Geo：全局几何稳定性
-
-## 9.1 Relation 内距离矩阵
-
-为减少 relation 不平衡和 relation 间宏观差异的支配作用，KTS-Geo 按 relation 计算后再宏平均。
-
-对于 relation \(r\)，定义：
-
-\[
-\mathcal D_{r,t,t'}
-=
-\{f\in\mathcal D_{t,t'}:r_f=r\}.
-\]
-
-仅保留至少包含 5 条事实的 relation。
-
-在 family \(t\) 下构造 relation 内距离：
-
-\[
-D^\ell_{m,t,r}(f,g)
-=
-1-
-\cos
-\left(
-v^\ell_{m,f,t},
-v^\ell_{m,g,t}
-\right).
-\]
-
-在 family \(t'\) 下类似构造：
-
-\[
-D^\ell_{m,t',r}(f,g).
-\]
-
-## 9.2 Relation 内几何相关性
-
-\[
-\rho^\ell_{m,r}(t,t')
-=
-\operatorname{Spearman}
-\left(
-\operatorname{vec}_{f<g}D^\ell_{m,t,r},
-\operatorname{vec}_{f<g}D^\ell_{m,t',r}
-\right).
-\]
-
-## 9.3 Relation-macro KTS-Geo
-
-\[
-\boxed{
-\mathrm{KTS}^{\mathrm{geo}}_{m,\ell}(t,t')
-=
-\frac{1}{|\mathcal R_{t,t'}|}
-\sum_{r\in\mathcal R_{t,t'}}
-\rho^\ell_{m,r}(t,t')
-}
-\]
-
-该值范围为：
-
-\[
-[-1,1].
-\]
-
-解释：
-
-- 1：事实距离排序完全保持；
-- 0：两个条件下的事实几何无显著对应；
-- 负值：事实距离结构发生反向重排。
-
-为了与 KTS-ID 合成，需要映射到 \([0,1]\)：
-
-\[
-\widetilde{\mathrm{KTS}}^{\mathrm{geo}}
-=
-\frac{
-\mathrm{KTS}^{\mathrm{geo}}+1
-}{2}.
-\]
-
----
-
-# 10. KTS-ID：事实身份稳定性
-
-全局距离结构可能看起来类似，但局部事实身份仍可能交换，因此需要 cross-condition fact identification。
-
-## 10.1 跨条件最近邻检索
-
-对于事实 \(f\) 在 family \(t\) 下的表示，在 family \(t'\) 的同 relation 事实中检索最近邻：
-
-\[
-\hat f_{t\rightarrow t'}
-=
-\arg\max_{
-g\in\mathcal D_{r_f,t,t'}
-}
-\cos
-\left(
-v^\ell_{m,f,t},
-v^\ell_{m,g,t'}
-\right).
-\]
-
-反向同样计算：
-
-\[
-\hat f_{t'\rightarrow t}.
-\]
-
-## 10.2 Relation 内 Top-1 身份准确率
-
-\[
-\mathrm{ID}_{m,\ell,r}(t\rightarrow t')
-=
-\frac{1}{|\mathcal D_{r,t,t'}|}
-\sum_{f\in\mathcal D_{r,t,t'}}
-\mathbb I[
-\hat f_{t\rightarrow t'}=f
-].
-\]
-
-进行双向平均：
-
-\[
-\mathrm{ID}^{\mathrm{sym}}_{m,\ell,r}(t,t')
-=
-\frac{
-\mathrm{ID}_{m,\ell,r}(t\rightarrow t')
-+
-\mathrm{ID}_{m,\ell,r}(t'\rightarrow t)
-}{2}.
-\]
-
-## 10.3 Chance correction
-
-若 relation \(r\) 有 \(n_r\) 条事实，随机 Top-1 命中的概率为：
-
-\[
-b_r=\frac{1}{n_r}.
-\]
-
-定义 chance-corrected identity：
-
-\[
-\mathrm{ID}^{\mathrm{adj}}_{m,\ell,r}
-=
-\frac{
-\mathrm{ID}^{\mathrm{sym}}_{m,\ell,r}-b_r
-}{
-1-b_r+\epsilon
-}.
-\]
-
-用于合成时裁剪到：
-
-\[
-[0,1].
-\]
-
-## 10.4 Relation-macro KTS-ID
-
-\[
-\boxed{
-\mathrm{KTS}^{\mathrm{id}}_{m,\ell}(t,t')
-=
-\frac{1}{|\mathcal R_{t,t'}|}
-\sum_{r\in\mathcal R_{t,t'}}
-\operatorname{clip}
-\left(
-\mathrm{ID}^{\mathrm{adj}}_{m,\ell,r},
-0,1
-\right)
-}
-\]
-
-建议同时报告原始：
-
-- Top-1 accuracy；
-- Top-5 accuracy；
-- mean reciprocal rank；
-- chance-corrected Top-1。
-
-主 KTS 使用 chance-corrected Top-1。
-
----
-
-# 11. KTS 合成
-
-对于 family pair \((t,t')\) 和层 \(\ell\)，定义：
-
-\[
-g
-=
-\widetilde{\mathrm{KTS}}^{\mathrm{geo}}_{m,\ell}(t,t'),
-\]
-
-\[
-i
-=
-\mathrm{KTS}^{\mathrm{id}}_{m,\ell}(t,t').
-\]
-
-使用调和平均：
-
-\[
-\boxed{
-\mathrm{KTS}_{m,\ell}(t,t')
-=
-\frac{
-2gi
-}{
-g+i+\epsilon
-}
-}
-\]
-
-使用调和平均的原因是：
-
-- 只有几何稳定但事实身份无法匹配，不应获得高 KTS；
-- 只有身份匹配但整体邻域结构严重扭曲，也不应获得高 KTS。
-
-## 11.1 跨 family pair 平均
-
-主 family pair 集：
-
-\[
-\mathcal P_{\mathcal T}
-=
-\{(t,t'):t,t'\in\mathcal T,\ t<t'\}.
-\]
-
-每个 pair 等权：
-
-\[
-\mathrm{KTS}_{m,\ell}
-=
-\frac{1}{|\mathcal P_{\mathcal T}|}
-\sum_{(t,t')\in\mathcal P_{\mathcal T}}
-\mathrm{KTS}_{m,\ell}(t,t').
-\]
-
-不能按 pair 中 query 数或事实数加权，否则覆盖更大的 family 会支配结果。
-
-## 11.2 跨层 KTS
-
-\[
-\boxed{
-\mathrm{KTS}_m
-=
-\frac{1}{|\mathcal W_m|}
-\sum_{\ell\in\mathcal W_m}
-\mathrm{KTS}_{m,\ell}
-}
-\]
-
-建议主表同时展示：
-
-- KTS-Geo；
-- KTS-ID；
-- KTS composite。
-
-不要只报告 composite 而隐藏两个组成部分。
-
----
-
-# 12. 四个指标的联合解释
-
-| BCS/BES | ISS | KTS | 解释 |
-|---|---:|---:|---|
-| 高 | 高 | 高 | 输出、单事实状态和整体知识结构均稳定 |
-| 高 | 低 | 低 | 表面答案一致，但内部状态和知识组织不稳定 |
-| 高 | 高 | 低 | 单事实局部状态一致，但整体空间可能坍缩或重排 |
-| 低 | 高 | 高 | 内部知识较稳定，失败更可能发生在后期选择或表达 |
-| 低 | 低 | 高 | 不同条件引起统一坐标变化，但知识拓扑仍保持 |
-| 低 | 低 | 低 | 外部行为、单事实状态和知识空间均不稳定 |
-
-对于 Stable Wrong：
-
-- BCS/BES 高；
-- 主 cluster 被判为错误；
-- ISS 和 KTS 高；
-
-表示模型可能稳定形成并组织了一个错误事实关联。
-
-这不应称为“正确知识稳定”，而应称为：
-
-> stable internal misalignment 或 stable wrong association。
-
----
-
-# 13. 推荐主结果表
-
-## 13.1 模型总体结果
-
-| Model | Anchor Acc. | BCS | BES | Stable Correct | Stable Wrong | Stable Abstention | ISS | KTS-Geo | KTS-ID | KTS |
-|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|
-| Model A |  |  |  |  |  |  |  |  |  |  |
-| Model B |  |  |  |  |  |  |  |  |  |  |
-
-## 13.2 按行为类型分析内部稳定性
-
-| Behavior group | Facts | ISS | KTS-Geo | KTS-ID | KTS |
-|---|---:|---:|---:|---:|---:|
-| Stable Correct |  |  |  |  |  |
-| Stable Wrong |  |  |  |  |  |
-| Stable Abstention |  |  |  |  |  |
-| Unstable |  |  |  |  |  |
-
-## 13.3 按 condition pair 报告 KTS
-
-| Pair | Shared facts | KTS-Geo | KTS-ID | KTS |
-|---|---:|---:|---:|---:|
-| Anchor–Paraphrase |  |  |  |  |
-| Anchor–Format |  |  |  |  |
-| Anchor–Context |  |  |  |  |
-| Anchor–Multilingual |  |  |  |  |
-| Paraphrase–Format |  |  |  |  |
-| ... |  |  |  |  |
-
----
-
-# 14. 推荐统计协议
-
-## 14.1 Relation-clustered bootstrap
-
-由于 21 个 relation 的事实数量不均衡，不能只对所有事实进行普通独立 bootstrap。
-
-推荐：
-
-1. 有放回采样 relation；
-2. 在每个采样 relation 内有放回采样事实；
-3. 重复 1,000 次；
-4. 报告 95% percentile confidence interval。
-
-对 KTS-Geo 和 KTS-ID，应在每次 bootstrap 内重新计算关系宏平均。
-
-## 14.2 模型间比较
-
-比较模型 A 和 B 时使用 paired bootstrap：
-
-- 每次使用相同的 relation 和 fact 重采样；
-- 计算指标差：
-  \[
-  \Delta=\mathrm{Metric}_A-\mathrm{Metric}_B;
-  \]
-- 报告 \(\Delta\) 的 95% CI。
-
-## 14.3 随机性控制
-
-必须固定：
-
-- 模型 revision；
-- tokenizer revision；
-- generation 参数；
-- Judge 模型和 revision；
-- Judge temperature；
-- negative fact sampling；
-- PCA 或 randomized SVD seed；
-- bootstrap seed。
-
----
-
-# 15. 评测流程
-
-```text
-固定 2,592 条事实和 query bank
-          |
-          v
-对每个模型运行全部 query 的贪婪生成
-          |
-          v
-Reference-blind AI Judge 抽取与语义聚类
-          |
-          +--> Reference-aware Judge 标记正确性
-          |
-          +--> 计算 BCS、BES 和行为类别
-          |
-          v
-提取主前向 query 的 query-end hidden states
-          |
-          v
-计算 J-Lens Jacobian transport
-          |
-          v
-relation/condition 残差化 + whitening
-          |
-          v
-构造每个 fact-family 的 centroid
-          |
-          +--> 计算 ISS
-          |
-          +--> 构建 condition-specific knowledge spaces
-                    |
-                    +--> KTS-Geo
-                    +--> KTS-ID
-                    +--> KTS composite
-```
-
----
-
-# 16. Python 风格伪代码
-
-## 16.1 BCS 和 BES
-
-```python
-from collections import defaultdict
-import math
-
-
-def compute_bcs_bes(records, main_families):
-    family_cluster_counts = defaultdict(lambda: defaultdict(int))
-    family_totals = defaultdict(int)
-
-    for item in records:
-        family = item["condition_family"]
-        if family not in main_families:
-            continue
-        cluster = item["cluster_id"]
-        family_cluster_counts[family][cluster] += 1
-        family_totals[family] += 1
-
-    valid_families = sorted(family_totals)
-    if not valid_families:
-        raise ValueError("No valid main-family queries.")
-
-    clusters = {
-        cluster
-        for family in valid_families
-        for cluster in family_cluster_counts[family]
-    }
-
-    p = {}
-    for cluster in clusters:
-        p[cluster] = sum(
-            family_cluster_counts[family].get(cluster, 0)
-            / family_totals[family]
-            for family in valid_families
-        ) / len(valid_families)
-
-    modal_cluster = max(p, key=p.get)
-    bcs = p[modal_cluster]
-
-    positive_probs = [value for value in p.values() if value > 0]
-    if len(positive_probs) == 1:
-        bes = 1.0
-    else:
-        entropy = -sum(value * math.log(value) for value in positive_probs)
-        bes = 1.0 - entropy / math.log(len(positive_probs))
-
-    return {
-        "bcs": bcs,
-        "bes": bes,
-        "modal_cluster": modal_cluster,
-        "cluster_distribution": p,
-        "valid_families": valid_families,
-    }
-```
-
-## 16.2 Family centroid
-
-```python
-import numpy as np
-
-
-def l2_normalize(x, eps=1e-12):
-    return x / max(np.linalg.norm(x), eps)
-
-
-def family_centroid(query_vectors):
-    normalized = [l2_normalize(x) for x in query_vectors]
-    return l2_normalize(np.mean(normalized, axis=0))
-```
-
-## 16.3 单层 ISS
-
-```python
-def compute_iss_for_fact(
-    family_vectors,
-    same_relation_fact_vectors,
-    eps=1e-12,
-):
-    families = sorted(family_vectors)
-    positive = []
-    negative = []
-
-    for i, family_a in enumerate(families):
-        for family_b in families[i + 1:]:
-            va = family_vectors[family_a]
-            vb = family_vectors[family_b]
-            positive.append(float(np.dot(va, vb)))
-
-            pair_negatives = []
-            for other in same_relation_fact_vectors:
-                if family_a not in other or family_b not in other:
-                    continue
-                pair_negatives.append(
-                    0.5 * (
-                        float(np.dot(va, other[family_b]))
-                        + float(np.dot(vb, other[family_a]))
-                    )
-                )
-            if pair_negatives:
-                negative.append(float(np.mean(pair_negatives)))
-
-    s_pos = float(np.mean(positive))
-    s_neg = float(np.mean(negative))
-    iss = (s_pos - s_neg) / (1.0 - s_neg + eps)
-
-    return {
-        "s_positive": s_pos,
-        "s_background": s_neg,
-        "iss": iss,
-    }
-```
-
-## 16.4 KTS-ID
-
-```python
-def cross_condition_top1(vectors_a, vectors_b, fact_ids):
-    vectors_a = np.asarray([l2_normalize(x) for x in vectors_a])
-    vectors_b = np.asarray([l2_normalize(x) for x in vectors_b])
-
-    sim_ab = vectors_a @ vectors_b.T
-    sim_ba = vectors_b @ vectors_a.T
-
-    pred_ab = np.argmax(sim_ab, axis=1)
-    pred_ba = np.argmax(sim_ba, axis=1)
-    gold = np.arange(len(fact_ids))
-
-    acc_ab = np.mean(pred_ab == gold)
-    acc_ba = np.mean(pred_ba == gold)
-    acc_sym = 0.5 * (acc_ab + acc_ba)
-
-    chance = 1.0 / len(fact_ids)
-    adjusted = (acc_sym - chance) / max(1.0 - chance, 1e-12)
-
-    return {
-        "top1_symmetric": acc_sym,
-        "chance": chance,
-        "chance_corrected": float(np.clip(adjusted, 0.0, 1.0)),
-    }
-```
-
----
-
-# 17. 输出文件建议
-
-```text
-metrics/
-├── behavioral_per_query.jsonl
-├── behavioral_per_fact.jsonl
-├── behavioral_model_summary.json
-├── hidden_family_centroids/
-├── iss_per_fact_layer.jsonl
-├── iss_per_fact.jsonl
-├── iss_model_summary.json
-├── kts_per_pair_layer.jsonl
-├── kts_model_summary.json
-├── bootstrap_intervals.json
-└── evaluation_manifest.json
-```
-
-## 17.1 behavioral_per_fact.jsonl
-
-```json
-{
-  "model": "model_name",
-  "fact_id": "fact_000001",
-  "bcs": 0.95,
-  "bes": 0.82,
-  "modal_cluster": "ENTITY_Q90",
-  "modal_correctness": "CORRECT",
-  "behavior_group": "Stable Correct",
-  "valid_families": [
-    "anchor",
-    "paraphrase",
-    "format",
-    "context",
-    "multilingual"
-  ]
-}
-```
-
-## 17.2 iss_per_fact.jsonl
-
-```json
-{
-  "model": "model_name",
-  "fact_id": "fact_000001",
-  "relation": "capital",
-  "iss": 0.61,
-  "iss_peak": 0.79,
-  "iss_late": 0.65,
-  "layers_used": [12, 13, 14, 15, 16]
-}
-```
-
-## 17.3 kts_model_summary.json
-
-```json
-{
-  "model": "model_name",
-  "kts_geo": 0.54,
-  "kts_id": 0.68,
-  "kts": 0.60,
-  "family_pairs": {
-    "anchor__paraphrase": {
-      "shared_facts": 2592,
-      "kts_geo": 0.62,
-      "kts_id": 0.76,
-      "kts": 0.68
-    }
-  }
-}
-```
-
----
-
-# 18. 必做 sanity checks
-
-## 18.1 Query shuffle test
-
-随机打乱 fact_id 与 hidden representation 的对应关系后：
-
-- ISS 应明显下降；
-- KTS-ID 应接近 chance；
-- KTS-Geo 应接近 0。
-
-## 18.2 Duplicate-query test
-
-同一个 query 与自身比较时：
-
-- hidden cosine 应接近 1；
-- ISS 正样本部分应达到上界附近。
-
-## 18.3 Condition-label shuffle
-
-随机打乱 condition family 标签后，family residualization 和 family centroid 不应产生虚假的高稳定性。
-
-## 18.4 Relation-matched negative test
-
-使用同 relation negatives 得到的 ISS 应比随机跨 relation negatives 更严格。主结果必须使用同 relation negatives。
-
-## 18.5 Raw versus transported ablation
-
-报告：
-
-- Raw-ISS；
-- J-transported ISS。
-
-如果两者完全相同，需要检查 Jacobian transport 是否实际生效。
-
-## 18.6 Judge consistency
-
-对至少 300–500 条回答进行人工校验，报告：
-
-- answer extraction accuracy���
-- cluster equivalence accuracy；
-- correctness accuracy；
-- Cohen's \(\kappa\) 或 Krippendorff's \(\alpha\)。
-
----
-
-# 19. 推荐论文定义
-
-可以在论文中将四个指标概括为：
-
-> **Behavioral Consistency Score (BCS)** measures the family-balanced mass assigned to a model's modal semantic answer across retrieval conditions. **Behavioral Entropy Stability (BES)** measures the concentration of the complete semantic answer distribution. **Internal State Stability (ISS)** measures whether the same fact forms a consistent and fact-discriminative Jacobian-transported representation across retrieval conditions. **Knowledge Topology Stability (KTS)** measures whether fact identity and the relative geometry of the overall knowledge representation space are preserved across conditions.
-
-中文：
-
-> BCS 衡量不同检索条件下主语义答案所占的等条件权重；BES 衡量完整答案分布的集中程度；ISS 衡量同一事实是否跨条件形成一致且具有事实区分性的 Jacobian 运输表示；KTS 衡量不同条件下事实身份及整体知识空间相对几何是否保持。
-
----
-
-# 20. 最终最小报告集合
-
-每个模型至少报告：
-
-```text
-Anchor Accuracy
-BCS
-BES
-Stable Correct Rate
-Stable Wrong Rate
-Stable Abstention Rate
-Unstable Rate
-ISS
-KTS-Geo
-KTS-ID
-KTS
-```
-
-同时提供：
-
-- 按 relation 的 macro 结果；
-- 按 behavior group 的 ISS/KTS；
-- 按 condition pair 的 KTS；
-- 95% relation-clustered bootstrap confidence intervals；
-- complete-family 和 full-set 两种覆盖口径。

ICLR dataset/protocol/jacobian_transported_iss_engineering_spec (1).md

@@ -1,953 +0,0 @@
-# Engineering Specification for Jacobian-Transported ISS
-
-## 0. Purpose
-
-This document specifies how to implement the official Internal State Stability metric, abbreviated as ISS, using Jacobian-transported hidden states.
-
-The formal metric remains:
-
-\[
-z^\ell_{m,f,q}=J^\ell_m h^\ell_{m,f,q},
-\]
-
-where no vocabulary unembedding matrix is applied. The implementation may approximate \(J^\ell_m\), but the approximation must be independently validated and its numerical error must be reported.
-
-Raw-ISS is retained only for debugging and ablation. It is not the official metric.
-
----
-
-# 1. Official Definition
-
-For model \(m\), fact \(f\), query \(q\), and source layer \(\ell\), extract the query-end residual state:
-
-\[
-h^\ell_{m,f,q}\in\mathbb R^{d_m}.
-\]
-
-Define the corpus-averaged input-output Jacobian:
-
-\[
-J^\ell_m
-=
-\mathbb E_{x\sim\mathcal C}
-\left[
-\frac{\partial h^L_m(x)}{\partial h^\ell_m(x)}
-\right],
-\]
-
-where \(\mathcal C\) is an independent calibration corpus.
-
-The transported representation is:
-
-\[
-\boxed{z^\ell_{m,f,q}=J^\ell_m h^\ell_{m,f,q}}
-\]
-
-Do **not** compute:
-
-\[
-W_UJ^\ell_m h^\ell_{m,f,q}.
-\]
-
-The official ISS therefore operates in the final-layer residual basis rather than vocabulary-logit space.
-
----
-
-# 2. Formal Metric Versus Practical Estimator
-
-The formal metric uses the exact population average \(J^\ell_m\). The practical implementation uses a finite-corpus, finite-rank estimator:
-
-\[
-\widehat J^{\ell,(n,k)}_m.
-\]
-
-The practical transported state is:
-
-\[
-\widehat z^\ell_{m,f,q}
-=
-\widehat J^{\ell,(n,k)}_m h^\ell_{m,f,q}.
-\]
-
-The paper should distinguish:
-
-- \(\operatorname{ISS}\): the formal metric;
-- \(\widehat{\operatorname{ISS}}_{n,k}\): the empirical estimator.
-
-The approximation is acceptable only if it satisfies the validation criteria below.
-
----
-
-# 3. Why Full Jacobians Are Not the General Solution
-
-For hidden dimension \(d\):
-
-\[
-J^\ell_m\in\mathbb R^{d\times d}.
-\]
-
-Materializing this matrix is feasible only for small models. For large models with \(d=4096\), \(5120\), or more, exact recovery across many layers and calibration prompts is prohibitively expensive.
-
-Therefore:
-
-1. full Jacobians are used only for small-model calibration;
-2. large models use a randomized factorized estimator;
-3. approximation quality must be validated for every model rather than inferred from a small model.
-
----
-
-# 4. Overall Engineering Pipeline
-
-```text
-Stage A: Full-matrix calibration on a small model
-    |
-    v
-Stage B: Per-model approximation validation
-    |
-    v
-Stage C: Freeze estimator settings
-    |
-    v
-Stage D: Official ISS evaluation
-```
-
-The final test set must not be used to choose estimator hyperparameters.
-
----
-
-# 5. Stage A: Small-Model Full-Matrix Calibration
-
-Use Qwen2.5-0.5B as the primary exact-reference model.
-
-## 5.1 Exact finite-corpus reference
-
-For a fixed calibration corpus of \(n\) prompts, compute:
-
-\[
-J^{\ell,(n)}_{\mathrm{full}}
-=
-\frac{1}{n}
-\sum_{i=1}^{n}J^\ell_{x_i}.
-\]
-
-This is an exact empirical Jacobian for that finite corpus.
-
-Do not call it the exact population Jacobian or universal ground truth. Use one of the following terms:
-
-- full empirical Jacobian reference;
-- exact finite-corpus Jacobian.
-
-## 5.2 Layer coverage
-
-At minimum, compute full references for:
-
-- one early layer;
-- one middle layer;
-- one late layer.
-
-If feasible on Qwen2.5-0.5B, compute every layer.
-
-## 5.3 Candidate ranks
-
-Evaluate:
-
-\[
-k\in\{32,64,128,256,512,768\},
-\]
-
-subject to \(k<d\).
-
-Use nested random probes so that larger ranks contain the directions used at smaller ranks.
-
-## 5.4 Required validation statistics
-
-### Matrix approximation error
-
-\[
-E_F(k)
-=
-\frac{\|J_{\mathrm{full}}-\widehat J_k\|_F}
-{\|J_{\mathrm{full}}\|_F}.
-\]
-
-### Transported-vector relative error
-
-For held-out activation vectors \(h_i\):
-
-\[
-E_{\mathrm{vec}}(k)
-=
-\frac{1}{M}
-\sum_{i=1}^{M}
-\frac{\|J_{\mathrm{full}}h_i-\widehat J_kh_i\|_2}
-{\|J_{\mathrm{full}}h_i\|_2+\epsilon}.
-\]
-
-### Transported-vector cosine agreement
-
-\[
-C_{\mathrm{vec}}(k)
-=
-\frac{1}{M}
-\sum_{i=1}^{M}
-\cos(J_{\mathrm{full}}h_i,\widehat J_kh_i).
-\]
-
-### ISS absolute error
-
-\[
-E_{\mathrm{ISS}}(k)
-=
-\left|
-\operatorname{ISS}_{\mathrm{full}}
--
-\widehat{\operatorname{ISS}}_k
-\right|.
-\]
-
-### Per-fact ISS rank agreement
-
-\[
-\rho_{\mathrm{fact}}(k)
-=
-\operatorname{Spearman}
-\left(
-\{\operatorname{ISS}^{\mathrm{full}}_f\},
-\{\widehat{\operatorname{ISS}}^{(k)}_f\}
-\right).
-\]
-
-A low Frobenius error is not sufficient. The transported vectors and the final ISS must also be stable.
-
----
-
-# 6. Randomized Factorized Jacobian Estimator
-
-The estimator must define a linear operator that can be applied to arbitrary hidden states. Computing only \(J\Omega\) is not enough.
-
-Use randomized range finding with a two-sided operator estimate.
-
-## 6.1 Random probe matrix
-
-For target rank \(k\), draw:
-
-\[
-\Omega\in\mathbb R^{d\times(k+p)},
-\]
-
-where:
-
-- \(p\) is an oversampling dimension;
-- recommended \(p\in\{32,64\}\);
-- \(\Omega\) uses Gaussian or Rademacher entries;
-- all random seeds are fixed and recorded.
-
-## 6.2 Estimate the Jacobian output range
-
-Compute:
-
-\[
-Y
-=
-J^\ell\Omega
-=
-\mathbb E_x[J^\ell_x\Omega].
-\]
-
-Use batched Jacobian-vector products.
-
-Then compute:
-
-\[
-Q=\operatorname{qr}(Y),
-\]
-
-with:
-
-\[
-Q\in\mathbb R^{d\times(k+p)}.
-\]
-
-## 6.3 Estimate the reduced operator
-
-Compute:
-
-\[
-B=Q^\top J^\ell.
-\]
-
-Equivalently:
-
-\[
-B^\top=J^{\ell\top}Q.
-\]
-
-Use batched vector-Jacobian products.
-
-The final estimator is:
-
-\[
-\boxed{\widehat J^\ell=QB}
-\]
-
-and:
-
-\[
-\widehat J^\ell h=Q(Bh).
-\]
-
-## 6.4 Storage
-
-Store only:
-
-\[
-Q\in\mathbb R^{d\times r},
-\qquad
-B\in\mathbb R^{r\times d},
-\]
-
-where \(r=k+p\).
-
-Do not reconstruct and store the complete \(d\times d\) matrix.
-
-Since \(Q\) has orthonormal columns:
-
-\[
-\cos(Qy_1,Qy_2)=\cos(y_1,y_2).
-\]
-
-Therefore downstream cosine computations may use:
-
-\[
-y^\ell=Bh
-\]
-
-directly. Residualization and whitening must then be performed consistently in that reduced coordinate space.
-
----
-
-# 7. Per-Model Validation Is Mandatory
-
-A rank that works for Qwen2.5-0.5B must not be assumed to work for larger models.
-
-Different models can have different:
-
-- hidden dimensions;
-- Jacobian singular-value decay;
-- effective rank;
-- depth;
-- normalization;
-- architecture;
-- post-training behavior.
-
-The small-model experiment validates the estimator implementation. It does not determine one universal rank.
-
-## 7.1 Direct action validation
-
-For every evaluated model, select representative:
-
-- early layers;
-- middle layers;
-- late layers.
-
-For held-out activation vectors \(h_i\), directly compute:
-
-\[
-u_i=J^\ell h_i
-=
-\frac1n\sum_{x\in\mathcal C}J^\ell_xh_i.
-\]
-
-This does not require materializing the full Jacobian.
-
-Compare with:
-
-\[
-\widehat u_i=\widehat J^\ell_kh_i.
-\]
-
-## 7.2 Validation activation set
-
-Use a calibration activation set independent of the final ISS test set.
-
-Recommended:
-
-- 64–128 activation vectors per representative layer;
-- multiple prompt types if benchmark-like prompts are used;
-- or a separate set of held-out natural questions.
-
-## 7.3 Rank candidates
-
-Use a nested grid such as:
-
-\[
-k\in\{64,128,256,512,1024\},
-\]
-
-bounded by model dimension and compute resources.
-
-Choose the smallest \(k_{m,\ell}\) that satisfies the fixed validation criteria.
-
-Recommended initial criteria:
-
-\[
-\operatorname{median}_i\cos(u_i,\widehat u_i)\ge0.99,
-\]
-
-\[
-\operatorname{median}_i
-\frac{\|u_i-\widehat u_i\|_2}
-{\|u_i\|_2+\epsilon}
-\le0.05,
-\]
-
-and:
-
-\[
-\left|
-\widehat{\operatorname{ISS}}_{2k}
--
-\widehat{\operatorname{ISS}}_k
-\right|
-\le0.01.
-\]
-
-The exact numeric thresholds may be adjusted after Stage A, but they must be frozen before final evaluation.
-
-## 7.4 Model-specific rank is allowed
-
-Different models and layers may use different ranks:
-
-\[
-k_{m,\ell}.
-\]
-
-This is methodologically acceptable because all models use the same approximation-quality standard.
-
-Always report:
-
-- \(k_{m,\ell}\);
-- \(k_{m,\ell}/d_m\);
-- validation cosine;
-- validation relative error;
-- rank-stability error.
-
----
-
-# 8. Calibration Corpus Size
-
-Rank error and corpus-sampling error are separate.
-
-The empirical Jacobian is:
-
-\[
-J^{\ell,(n)}
-=
-\frac1n\sum_{i=1}^{n}J^\ell_{x_i}.
-\]
-
-A large \(k\) does not compensate for insufficient corpus size \(n\).
-
-## 8.1 Corpus requirements
-
-The Jacobian corpus must:
-
-- be independent of the factual benchmark;
-- contain general pretraining-style or natural text;
-- use the same construction rule for all models;
-- use a fixed sequence-length and position convention;
-- record all sample IDs and random seeds.
-
-## 8.2 Corpus-size convergence
-
-On representative models, compare:
-
-\[
-n\in\{32,64,128,256,512\}.
-\]
-
-Measure:
-
-\[
-\cos(\widehat J^{(n)}h,\widehat J^{(2n)}h),
-\]
-
-and:
-
-\[
-\left|
-\widehat{\operatorname{ISS}}_n
--
-\widehat{\operatorname{ISS}}_{2n}
-\right|.
-\]
-
-Select \(n\) using a fixed convergence rule. Do not select \(n\) based on preferred final benchmark conclusions.
-
----
-
-# 9. Random-Seed Stability
-
-For representative model-layer-rank settings, use at least three sketch seeds.
-
-Report mean and standard deviation for:
-
-- transported-vector cosine;
-- transported-vector relative error;
-- ISS;
-- KTS if KTS uses the same transported states.
-
-A rank is not considered stable if results vary materially across seeds.
-
-Preferred final reporting:
-
-- average the result across three validated seeds; or
-- use one preregistered seed after proving seed variance is negligible.
-
-Never choose the seed that gives the preferred scientific result.
-
----
-
-# 10. Official ISS Computation
-
-After freezing the estimator, compute:
-
-\[
-\widehat z^\ell_{m,f,q}
-=
-\widehat J^\ell_m h^\ell_{m,f,q}.
-\]
-
-Then run the standard ISS pipeline.
-
-## 10.1 Relation and condition residualization
-
-\[
-\bar z^\ell_{m,f,q}
-=
-z^\ell_{m,f,q}
--
-\mu^\ell_{m,r_f}
--
-\mu^\ell_{m,t(q)}
-+
-\mu^\ell_m.
-\]
-
-## 10.2 Regularized whitening
-
-\[
-\tilde z^\ell_{m,f,q}
-=
-(\Sigma^\ell_m+\lambda I)^{-1/2}
-\bar z^\ell_{m,f,q}.
-\]
-
-If the reduced coordinate \(y=Bh\) is used directly, estimate \(\Sigma\) in that coordinate system.
-
-Do not fit a separate whitening transform for each condition family.
-
-## 10.3 Family centroid
-
-\[
-v^\ell_{m,f,t}
-=
-\operatorname{Normalize}
-\left(
-\frac1{|Q_{f,t}|}
-\sum_{q\in Q_{f,t}}
-\tilde z^\ell_{m,f,q}
-\right).
-\]
-
-## 10.4 Same-fact cross-condition similarity
-
-\[
-S^+_{m,f,\ell}
-=
-\frac1{|\mathcal P_f|}
-\sum_{(t,t')\in\mathcal P_f}
-\cos(v^\ell_{m,f,t},v^\ell_{m,f,t'}).
-\]
-
-## 10.5 Relation-matched background
-
-\[
-S^-_{m,f,\ell}
-=
-\mathbb E_{\substack{g\neq f,\ r_g=r_f\\t\neq t'}}
-\cos(v^\ell_{m,f,t},v^\ell_{m,g,t'}).
-\]
-
-## 10.6 Official ISS estimator
-
-\[
-\boxed{
-\widehat{\operatorname{ISS}}_{m,f,\ell}
-=
-\frac{S^+_{m,f,\ell}-S^-_{m,f,\ell}}
-{1-S^-_{m,f,\ell}+\epsilon}
-}
-\]
-
-Average over the preregistered layer window:
-
-\[
-\widehat{\operatorname{ISS}}_{m,f}
-=
-\frac1{|\mathcal W_m|}
-\sum_{\ell\in\mathcal W_m}
-\widehat{\operatorname{ISS}}_{m,f,\ell}.
-\]
-
-Then average over the fixed fact set:
-
-\[
-\widehat{\operatorname{ISS}}_m
-=
-\frac1{|\mathcal D|}
-\sum_{f\in\mathcal D}
-\widehat{\operatorname{ISS}}_{m,f}.
-\]
-
----
-
-# 11. Raw-ISS
-
-Raw-ISS uses:
-
-\[
-z^\ell_{m,f,q}=h^\ell_{m,f,q}.
-\]
-
-It should be computed because it is inexpensive and useful for:
-
-- debugging hidden-state extraction;
-- validating family aggregation;
-- validating negative sampling;
-- checking whitening and residualization;
-- ablation;
-- testing whether Jacobian transport changes the conclusion.
-
-However:
-
-\[
-\boxed{\text{Raw-ISS is not the official ISS result.}}
-\]
-
-Recommended table terminology:
-
-| Metric | Representation | Role |
-|---|---|---|
-| Raw-ISS | \(h^\ell\) | Identity-transport ablation |
-| ISS | \(\widehat J^\ell h^\ell\) | Official metric |
-| Token readout | \(W_U\widehat J^\ell h^\ell\) | Not used |
-
----
-
-# 12. Failure Policy
-
-Do not silently report an unvalidated approximation.
-
-A model-layer estimator fails validation if:
-
-- rank convergence is not achieved;
-- action-vector cosine remains below threshold;
-- relative action error remains above threshold;
-- ISS changes materially across ranks;
-- ISS changes materially across random seeds.
-
-## 12.1 Allowed responses
-
-In order:
-
-1. increase \(k\);
-2. increase oversampling \(p\);
-3. increase corpus size \(n\);
-4. add power iterations;
-5. restrict official ISS to validated layers;
-6. mark the model-layer estimator as unresolved.
-
-Raw-ISS may still be reported as an ablation, but it must not be relabeled as official ISS.
-
-## 12.2 Optional fallback estimator
-
-If low-rank reconstruction consistently fails, consider a geometry-preserving output sketch:
-
-\[
-RJ^\ell h,
-\]
-
-where:
-
-\[
-R\in\mathbb R^{k\times d}.
-\]
-
-This avoids assuming that \(J^\ell\) itself is low rank. However, it is a different estimator and must be separately validated against the full small-model reference.
-
-Do not switch to this estimator silently.
-
----
-
-# 13. Data Separation
-
-Use three disjoint resources.
-
-## 13.1 Jacobian corpus
-
-Used to estimate \(J^\ell_m\). It must contain independent general text.
-
-## 13.2 Estimator calibration set
-
-Used to select:
-
-- corpus size \(n\);
-- rank \(k\);
-- sketch seed;
-- oversampling;
-- power iterations;
-- approximation thresholds.
-
-It must not overlap with the final benchmark evaluation facts.
-
-## 13.3 Final ISS benchmark
-
-Used only after all estimator settings are frozen.
-
-Do not tune \(n\), \(k\), seeds, layer windows, or whitening choices on the final benchmark.
-
----
-
-# 14. Required Output Files
-
-```text
-jacobian_iss/
-├── configs/
-│   ├── corpus_config.yaml
-│   ├── estimator_config.yaml
-│   ├── validation_thresholds.yaml
-│   └── layer_windows.yaml
-├── full_reference/
-│   └── qwen2.5_0.5b/
-├── low_rank_factors/
-│   └── {model}/{layer}/
-│       ├── Q.pt
-│       ├── B.pt
-│       └── metadata.json
-├── validation/
-│   ├── small_model_full_comparison.json
-│   ├── per_model_action_validation.jsonl
-│   ├── rank_convergence.jsonl
-│   ├── corpus_convergence.jsonl
-│   └── seed_stability.jsonl
-├── transported_states/
-├── iss_per_fact_layer.jsonl
-├── iss_per_fact.jsonl
-├── iss_model_summary.json
-└── raw_iss_ablation.json
-```
-
----
-
-# 15. Required Metadata
-
-For every estimator, store:
-
-```json
-{
-  "model": "model_name",
-  "model_revision": "revision",
-  "tokenizer_revision": "revision",
-  "layer": 16,
-  "hidden_dimension": 4096,
-  "rank": 512,
-  "oversampling": 64,
-  "power_iterations": 0,
-  "calibration_corpus_size": 256,
-  "calibration_sequence_length": 128,
-  "random_seed": 42,
-  "validation_cosine_median": 0.993,
-  "validation_relative_error_median": 0.041,
-  "iss_rank_difference": 0.006,
-  "validated": true
-}
-```
-
----
-
-# 16. Minimum Required Experiments
-
-## Experiment A: Full-reference calibration
-
-Model:
-
-```text
-Qwen2.5-0.5B
-```
-
-Compare:
-
-```text
-full empirical Jacobian
-vs.
-rank 32/64/128/256/512/768 approximations
-```
-
-Report:
-
-- Frobenius error;
-- transported-vector error;
-- transported-vector cosine;
-- ISS absolute error;
-- per-fact ISS Spearman correlation.
-
-## Experiment B: Medium-scale transfer check
-
-Use at least one medium-sized model.
-
-At representative layers:
-
-- compute high-accuracy direct \(Jh\) actions;
-- validate rank behavior;
-- confirm that the small-model rank does not automatically transfer.
-
-## Experiment C: Per-model validation
-
-For every evaluated model:
-
-- representative early, middle, and late layers;
-- 64–128 held-out activation vectors;
-- nested candidate ranks;
-- fixed validation thresholds;
-- at least three random seeds on representative settings.
-
-## Experiment D: Official evaluation
-
-Only after freezing all estimator choices:
-
-- compute transported states;
-- compute official ISS;
-- compute Raw-ISS;
-- compare trends;
-- report approximation uncertainty.
-
----
-
-# 17. Recommended Decision Rule
-
-Do not use:
-
-```text
-k = 512 for every model
-```
-
-Use:
-
-```text
-Choose the smallest k for each model-layer that satisfies
-one fixed approximation-quality standard.
-```
-
-Recommended initial rule:
-
-```text
-median action cosine >= 0.99
-median relative action error <= 0.05
-|ISS(2k) - ISS(k)| <= 0.01
-seed standard deviation of ISS <= 0.005
-```
-
-The exact thresholds may be refined after the small-model calibration, but they must be frozen before final evaluation.
-
----
-
-# 18. Uncertainty Reporting
-
-Separate the following sources of uncertainty:
-
-1. finite Jacobian-corpus error;
-2. low-rank approximation error;
-3. random-sketch error;
-4. benchmark sampling uncertainty;
-5. relation-level heterogeneity.
-
-At minimum, report:
-
-- rank sensitivity;
-- corpus-size sensitivity;
-- random-seed sensitivity;
-- per-model action validation;
-- relation-clustered bootstrap confidence intervals for final ISS.
-
-Do not present one confidence interval that silently mixes all uncertainty sources.
-
----
-
-# 19. Paper-Ready Method Description
-
-> We define Internal State Stability on Jacobian-transported residual states \(z^\ell=J^\ell h^\ell\), where \(J^\ell\) is the corpus-averaged input-output Jacobian from layer \(\ell\) to the final residual stream. We do not apply the vocabulary unembedding matrix, thereby retaining a continuous hidden representation compatible with multi-token and multilingual answers. Since explicitly materializing \(J^\ell\in\mathbb R^{d\times d}\) is prohibitive for large models, we estimate it using randomized range finding, yielding a factorized operator \(\widehat J^\ell=Q^\ell B^\ell\). We validate this approximation against full empirical Jacobians on Qwen2.5-0.5B and against directly computed Jacobian-vector products on held-out activations for every evaluated model. The sketch rank is selected independently for each model and layer using a fixed preregistered approximation-error tolerance rather than a universal rank or final benchmark performance.
-
-Continuation:
-
-> We separately evaluate calibration-corpus convergence, rank convergence, and random-seed stability. Raw hidden-state ISS is reported only as an identity-transport ablation.
-
----
-
-# 20. Final Engineering Decisions
-
-```text
-Official ISS:
-    Jacobian-transported hidden-state ISS
-
-Transport:
-    z = J h
-
-Unembedding:
-    Do not multiply by W_U
-
-Small-model full Jacobian:
-    Finite-corpus exact reference only
-
-Large-model implementation:
-    Randomized factorized operator estimate
-
-Rank selection:
-    Per model and per layer
-
-Rank criterion:
-    Shared fixed approximation-quality threshold
-
-Validation:
-    Full matrix comparison on Qwen2.5-0.5B
-    Direct J h comparison on every evaluated model
-
-Raw-ISS:
-    Debugging and ablation only
-
-Final test set:
-    Never used to tune n, k, seeds, layers, or estimator settings
-
-Failure:
-    Do not report unvalidated Jacobian ISS
-```
-
----
-
-# 21. Immediate Implementation Order for Claude
-
-1. Finish Raw-ISS to validate data loading and metric aggregation.
-2. Implement exact finite-corpus Jacobian recovery on Qwen2.5-0.5B.
-3. Implement the randomized factorized estimator \(\widehat J=QB\).
-4. Compare candidate ranks against the full small-model reference.
-5. Measure matrix, vector-action, ISS-value, and fact-ranking errors.
-6. Freeze approximation-quality thresholds.
-7. Implement direct \(Jh\) validation for large models.
-8. Select \(k_{m,\ell}\) using the fixed thresholds.
-9. Run corpus-size and seed-stability checks.
-10. Freeze all estimator configurations.
-11. Compute official ISS on the final benchmark.
-12. Report Raw-ISS only as an ablation.
-13. Save all factors, configurations, validation logs, and checksums.
-
-The objective is not to recover every Jacobian entry exactly. The objective is to guarantee that the transported representations and the resulting ISS remain within a preregistered numerical tolerance.

ICLR dataset/protocol/reconstruction_differences.md

@@ -1,218 +0,0 @@
-# Reconstruction differences
-
-Required by spec section 10: every deviation from the expected counts, and every
-internal contradiction found in the specification itself, is recorded here
-rather than silently absorbed.
-
-Build: `dataset3/`, sources read from `ICLR27/dataset/`.
-
----
-
-## Summary
-
-| Stage | Expected | Actual | Status |
-|---|---:|---:|---|
-| Raw cloze prompts | 1,783,541 | 1,783,541 | match |
-| Five-model consensus | 10,601 | 10,601 | match |
-| Candidate-Known Facts | 8,107 | 8,107 | match |
-| Grouped (subject, relation) | 6,185 | 6,185 | match |
-| Functional conflicts removed | 5 | 5 | match |
-| Enriched Facts | 6,180 | 6,180 | match |
-| Core-source facts | 3,705 | 3,705 | match |
-| Benchmark facts | 2,592 | 2,592 | match |
-| Benchmark relations | 21 | 21 | match |
-| Migration duplicates removed | 10,323 | 10,323 | match |
-| Evaluation queries | 44,418 | **44,416** | **deviation D1** |
-| — context | 6,831 | **6,829** | **deviation D1** |
-| — all other conditions | as specified | as specified | match |
-
-Everything except D1 reproduces exactly.
-
----
-
-## D1 — Two context queries expose the gold answer (defect in the source data)
-
-**Deviation:** context 6,831 → 6,829; total 44,418 → 44,416.
-
-Spec 9.4 requires that context "must not introduce a second valid target", and
-spec 13.9 that "no gold answer is exposed in open-ended main conditions". Two
-queries migrated from `eval_dataset/queryD_context.jsonl` violate both, because
-the legacy distractor sampler picked an entity whose surface form contains the
-gold answer:
-
-```
-Some people confuse States Reorganisation Act with Indian Act.
-In which jurisdiction does States Reorganisation Act apply?
-   gold = India          <- exposed by the distractor "Indian Act"
-
-Taiwan (ROC) Resident Certificate is a legal term in Taiwan.
-Indian Act is a legal term in Canada.
-In which jurisdiction does Permanent account number apply?
-   gold = India          <- same cause
-```
-
-Spec 10 allows a count change when "the implementation discovers a documented
-defect in the old data". This is such a defect.
-
-**Action taken.** `src/build_eval_bank.py` applies a general rule rather than a
-hard-coded exception: for every open-ended main-forward query, the normalized
-gold must not appear in the query text after removing all mentions of the
-subject. Queries failing the rule are dropped and counted in
-`stage4_report.json` as `dropped_gold_exposed`.
-
-**To restore 44,418** exactly, delete that guard — but the two queries are
-unanswerable-by-design artefacts and any model scores them correct by copying.
-
----
-
-## C1 — Spec 6.2 contradicts the required benchmark size (unresolved by design)
-
-**Not a count deviation. An internal contradiction in the specification.**
-
-Spec 6.2 lists relations "generally unsuitable" for the main benchmark, naming
-among them **developer of** and **manufacturer of**. Spec 1, 6.2 and 15
-simultaneously require exactly **2,592 facts across 21 relations**.
-
-Those two relations contribute:
-
-| Relation | Facts |
-|---|---:|
-| manufacturer (P176) | 441 |
-| developer (P178) | 405 |
-| **total** | **846** |
-
-Excluding them yields **1,746 facts across 19 relations**, which fails the
-acceptance criteria in spec 15. Keeping them satisfies the counts but contradicts
-spec 6.2's guidance.
-
-**Action taken.** The counts win, because spec 15 states them as acceptance
-criteria and spec 10 forbids silent changes. Both relations are retained and
-tagged:
-
-```json
-"spec_6_2_flag": "unsuitable_named_in_spec"
-```
-
-`configs/relations.yaml` exposes `options.drop_spec_6_2_flagged`. Setting it to
-`true` reproduces the spec-6.2-compliant 1,746-fact variant; the selection script
-then reports the resulting size instead of failing.
-
-**Recommendation.** Report the headline number on all 2,592 and a robustness
-number on the 1,746 subset. See F1, which gives an independent empirical reason
-to distrust exactly these relations.
-
----
-
-## F1 — 28.9% of benchmark facts are answerable by string copying
-
-**Finding, not a deviation. No counts changed.**
-
-For 750 of 2,592 benchmark facts (28.9%) the object string is literally contained
-in the subject name, so the query can be answered by copying a substring instead
-of retrieving knowledge:
-
-```
-Airbus A318            -> manufacturer  Airbus
-Adobe Acrobat          -> developer     Adobe
-Amazon Music           -> owned by      Amazon
-Agriculture and Agri-Food Canada -> jurisdiction  Canada
-```
-
-Concentration by relation:
-
-| Relation | Flagged | Total | Share |
-|---|---:|---:|---:|
-| manufacturer | 387 | 441 | 87.8% |
-| developer | 199 | 405 | 49.1% |
-| owned_by | 52 | 89 | 58.4% |
-| applies_to_jurisdiction | 31 | 54 | 57.4% |
-| sport | 17 | 81 | 21.0% |
-| country | 17 | 263 | 6.5% |
-| headquarters_location | 15 | 132 | 11.4% |
-| (10 further relations) | 32 | — | <34% |
-
-586 of the 750 come from `manufacturer` and `developer` — the two relations spec
-6.2 already called unsuitable. F1 is therefore independent empirical support for
-C1's recommendation.
-
-**Why this matters.** A stability benchmark measures whether a *retrieved* fact
-survives rephrasing. A fact answerable by copying is stable for a reason that has
-nothing to do with knowledge, so it inflates every retention number and dampens
-the very effect the study is about.
-
-**Action taken.** Spec 16 forbids silently dropping facts, so all 750 are kept
-and flagged on both the fact and the query record:
-
-```json
-"answer_in_subject_surface": true
-```
-
-Downstream analysis should report retention with and without them.
-
----
-
-## F2 — 808 of the 8,107 candidate rows are exact duplicates
-
-**Finding, not a deviation.**
-
-The 8,107 Candidate-Known Facts contain only 7,299 distinct
-`(subject, relation, object, source)` tuples; 808 rows are exact repeats, e.g.
-`("BMW 3 Series", P176, "BMW", counterfact)` appears twice. This is inherited
-from `dataset/filter/prompts.jsonl`.
-
-No action needed: spec 5.1 grouping absorbs them, which is part of why 8,107 rows
-become 6,185 groups. Recorded so the 8,107 figure is not mistaken for 8,107
-distinct facts.
-
----
-
-## N1 — Stage I GPU passes were not re-executed
-
-The five-model first-token forward passes (1,783,541 prompts x 5 models) were
-run previously; their per-prompt verdict vectors are stored as
-`dataset/filter/correct_<model>.npy`.
-
-`src/build_candidate_known.py` re-derives the candidate set from those vectors:
-it re-reads the prompt table, re-computes the intersection, re-applies the
-source-drop rule, and checksums every input into `stage1_report.json`. It does
-not re-run inference.
-
-The counts are verified, not assumed — 1,783,541 / 10,601 / 8,107 all reproduce,
-and the result is checked for set equality against
-`dataset/filter/global_known_clean.jsonl`.
-
-`src/filter_run.py` regenerates the vectors from scratch when required.
-
----
-
-## N2 — Triple direction is not normalized for `capital_of`
-
-Spec 2.2 requires a single triple direction, forward being
-`subject + relation -> object`. The relation `capital_of` (P1376) is stored the
-other way round: subject = city, object = country.
-
-Normalizing it would fold those 125 facts into `capital`, changing both the
-benchmark size and the relation count, which spec 10 forbids doing silently.
-
-**Action taken.** `capital_of` keeps `"direction": "inverse"` and
-`"inverse_of": "capital"` in its record, so any analysis can group or separate
-the two directions explicitly. `configs/relations.yaml` exposes
-`options.normalize_inverse_direction` for the alternative build.
-
----
-
-## Coverage gaps (spec 12, expected and unchanged)
-
-Main-forward families do not cover every fact:
-
-| Condition | Facts covered | Missing |
-|---|---:|---:|
-| anchor | 2,592 | 0 |
-| paraphrase | 2,592 | 0 |
-| format | 2,592 | 0 |
-| context | 2,591 | 1 |
-| multilingual | 2,402 | 190 |
-
-Missing fact ids are listed in `outputs/coverage_report.json`. No query was
-imputed. Downstream analyses that compare conditions per fact should use the
-explicit valid intersection.

ICLR dataset/runner/build_candidate_known.py

@@ -1,168 +0,0 @@
-#!/usr/bin/env python
-"""Stage I -> outputs/candidate_known_8107.jsonl  (spec sections 4.1 - 4.5)
-
-Stage I is the expensive part of the pipeline: 1,783,541 cloze prompts x 5
-models of GPU forward passes. Those passes were already run and their outputs
-live under dataset/filter/ as `correct_<model>.npy` vectors aligned to
-`prompts.jsonl`. This script therefore RECONSTRUCTS the candidate set from
-those stored per-model verdicts rather than re-running the GPU, while
-re-deriving every count from raw data so the numbers are verified, not assumed:
-
-  * prompts.jsonl and prompts_popqa.jsonl are re-read and counted;
-  * the five per-model vectors are re-intersected here, not taken on trust;
-  * the source-drop rule (spec 4.5) is re-applied;
-  * every input file is checksummed into the output header.
-
-Re-running the GPU stage from scratch is `src/filter_run.py`, which is kept
-byte-compatible with the stored vectors; use --verify_only to check that this
-reconstruction still matches dataset/filter/global_known_clean.jsonl.
-"""
-import os, sys, json, argparse, collections
-import numpy as np
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from common import (DATASET, load_config, out_path, read_jsonl, write_jsonl,
-                    sha256, Expect)
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--verify_only", action="store_true")
-    args = ap.parse_args()
-
-    src_cfg = load_config("source_templates.yaml")
-    mdl_cfg = load_config("models.yaml")
-    filter_models = [m["name"] for m in mdl_cfg["filter_models"]]
-    exp = Expect()
-
-    fdir = os.path.join(DATASET, "filter")
-    prompts_path = os.path.join(fdir, "prompts.jsonl")
-    popqa_path = os.path.join(fdir, "prompts_popqa.jsonl")
-
-    # ---- 1. cloze prompt table (spec 4.3) ----
-    print("[1/4] reading cloze prompt table ...", flush=True)
-    prompts = list(read_jsonl(prompts_path))
-    exp.check("cloze_prompts", len(prompts), src_cfg["expected"]["cloze_prompts"])
-
-    by_source = collections.Counter(p["source"] for p in prompts)
-    for name, s in src_cfg["sources"].items():
-        if s.get("added_after_consensus"):
-            continue
-        key = {"t_rex": "trex"}.get(name, name)
-        if key in by_source and "expected_triples" in s:
-            exp.check(f"prompts[{name}]", by_source[key], None)
-
-    # ---- 2. five-model consensus (spec 4.4) ----
-    print(f"[2/4] intersecting {len(filter_models)} first-token verdict vectors ...",
-          flush=True)
-    inter = np.ones(len(prompts), dtype=bool)
-    per_model = {}
-    for m in filter_models:
-        v = np.load(os.path.join(fdir, f"correct_{m}.npy")).astype(bool)
-        if len(v) != len(prompts):
-            raise SystemExit(f"correct_{m}.npy has {len(v)} rows, "
-                             f"prompts.jsonl has {len(prompts)}")
-        per_model[m] = float(v.mean())
-        inter &= v
-    exp.check("five_model_consensus", int(inter.sum()),
-              src_cfg["expected"]["five_model_consensus"])
-
-    # ---- 3. source filtering (spec 4.5) ----
-    drop = {name for name, s in src_cfg["sources"].items()
-            if s.get("drop_after_consensus")}
-    drop |= {"trex"} if "t_rex" in drop else set()
-    print(f"[3/4] dropping post-consensus sources: {sorted(drop)}", flush=True)
-
-    rows = []
-    for i, p in enumerate(prompts):
-        if not inter[i]:
-            continue
-        if p["source"] in drop:
-            continue
-        rows.append({
-            "raw_id": p["id"],
-            "prompt_id": f"p{i:07d}",
-            "source": p["source"],
-            "subject": p["subject"],
-            "relation": p["relation"],
-            "object": p["object"],
-            "cloze_prompt": p["prompt"],
-            "consensus": {"models": filter_models, "n_passed": len(filter_models)},
-            "legacy_ref": {"file": "prompts.jsonl", "row": i},
-        })
-
-    # ---- 4. PopQA supplement, same protocol (spec 4.5) ----
-    n_popqa = 0
-    if os.path.exists(popqa_path):
-        pq = list(read_jsonl(popqa_path))
-        exp.check("popqa_prompts", len(pq),
-                  src_cfg["sources"]["popqa"].get("expected_prompts"))
-        pinter = np.ones(len(pq), dtype=bool)
-        for m in filter_models:
-            v = np.load(os.path.join(fdir, f"popqa_correct_{m}.npy")).astype(bool)
-            pinter &= v
-        for i, p in enumerate(pq):
-            if not pinter[i]:
-                continue
-            rows.append({
-                "raw_id": p["id"],
-                "prompt_id": f"q{i:07d}",
-                "source": "popqa",
-                "subject": p["subject"],
-                "relation": p["relation"],
-                "object": p["object"],
-                "cloze_prompt": p["prompt"],
-                "consensus": {"models": filter_models, "n_passed": len(filter_models)},
-                "legacy_ref": {"file": "prompts_popqa.jsonl", "row": i},
-            })
-            n_popqa += 1
-        exp.check("popqa_passed", n_popqa,
-                  src_cfg["sources"]["popqa"].get("expected_passed"))
-
-    exp.check("candidate_known", len(rows), src_cfg["expected"]["candidate_known"])
-
-    # ---- cross-check against the legacy file ----
-    legacy = os.path.join(fdir, "global_known_clean.jsonl")
-    if os.path.exists(legacy):
-        want = {(d["subject"], d["relation"], d["object"], d["source"])
-                for d in read_jsonl(legacy)}
-        got = {(r["subject"], r["relation"], r["object"], r["source"]) for r in rows}
-        exp.check("matches_legacy_clean_set", len(got & want), len(want),
-                  note="set equality against dataset/filter/global_known_clean.jsonl")
-        if got != want:
-            print(f"  only-in-new: {len(got - want)}  only-in-legacy: {len(want - got)}")
-
-    exp.report("Stage I counts")
-    if args.verify_only:
-        return 1 if exp.deviations else 0
-
-    path = out_path("candidate_known_8107.jsonl")
-    write_jsonl(path, rows)
-
-    meta = {
-        "stage": "I_candidate_recall",
-        "n_candidate_known": len(rows),
-        "per_source": dict(collections.Counter(r["source"] for r in rows)),
-        "filter_models": filter_models,
-        "filter_model_first_token_accuracy": per_model,
-        "dropped_sources_after_consensus": sorted(drop),
-        "checks": exp.rows,
-        "inputs": {
-            "prompts.jsonl": sha256(prompts_path, limit_mb=64),
-            "prompts_popqa.jsonl": sha256(popqa_path) if os.path.exists(popqa_path) else None,
-            **{f"correct_{m}.npy": sha256(os.path.join(fdir, f"correct_{m}.npy"))
-               for m in filter_models},
-        },
-        "note": "GPU forward passes were not re-run; the stored per-model "
-                "first-token verdict vectors were re-intersected here. Use "
-                "src/filter_run.py to regenerate them from scratch.",
-    }
-    json.dump(meta, open(out_path("stage1_report.json"), "w"),
-              indent=2, ensure_ascii=False)
-    print(f"\nwrote {len(rows)} candidate facts -> {path}")
-    print(f"  per source: {meta['per_source']}")
-    return 1 if exp.deviations else 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

ICLR dataset/runner/build_eval_bank.py

@@ -1,253 +0,0 @@
-#!/usr/bin/env python
-"""Stage IV -> outputs/evaluation_queries_44418.jsonl  (spec sections 8 - 12)
-
-Builds the query bank on the FIXED 2,592-fact benchmark. Sources:
-  * anchor        the qualification question itself
-  * everything else migrated from eval_dataset/query{A..E}_*.jsonl
-
-Migration rules (spec 11):
-  * old `kid` -> `fact_id`, joined entity-aware; original ids preserved in
-    `legacy_query_refs`
-  * duplicates removed on (fact_id, normalized query, target slot, family)
-  * single-string gold replaced by an alias set from the enriched fact
-  * MCQ rows routed to `recognition`, never to `format`
-  * reverse rows with a non-unique inverse routed to `reverse_illposed`
-
-Condition family names follow configs/eval_conditions.yaml rather than the old
-file names, because those are a known trap: `queryA_canonical` holds surface
-rewrites and was reported as paraphrase, `queryB_paraphrase` holds format
-variants and was reported as format.
-"""
-import os, sys, json, glob, argparse, collections
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from common import (load_config, out_path, read_jsonl, write_jsonl,
-                    normalize, norm_key, Expect)
-
-EVAL_LEGACY = "/scratch/rds-fei-rsfm-rw/cshi0459/ICLR27/eval_dataset"
-FILE_FAMILY = {"queryA_canonical": "paraphrase", "queryB_paraphrase": "format",
-               "queryC_reverse": "reverse", "queryD_context": "context",
-               "queryE_multilingual": "multilingual"}
-ORDER = ["anchor", "paraphrase", "format", "context", "multilingual",
-         "reverse", "recognition", "reverse_illposed"]
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--facts", default=out_path("benchmark_facts_2592.jsonl"))
-    args = ap.parse_args()
-
-    cond_cfg = load_config("eval_conditions.yaml")
-    CONDS = cond_cfg["conditions"]
-    exp = Expect()
-
-    facts = list(read_jsonl(args.facts))
-    by_id = {f["fact_id"]: f for f in facts}
-    exp.check("benchmark_facts", len(facts), cond_cfg["totals"]["expected_benchmark_facts"])
-
-    # ---- kid -> fact_id, joined on (subject identity, source relation) ----
-    key2fid = {}
-    for f in facts:
-        for pid in f["relation"]["source_relations"]:
-            key2fid[(norm_key(f["subject"]["canonical"]), pid)] = f["fact_id"]
-        if f["subject"].get("entity_id"):
-            for pid in f["relation"]["source_relations"]:
-                key2fid[(f["subject"]["entity_id"], pid)] = f["fact_id"]
-
-    kid2fid, unmapped = {}, []
-    for b in read_jsonl(f"{EVAL_LEGACY}/base.jsonl"):
-        fid = key2fid.get((norm_key(b["subject"]), b["relation_id"]))
-        if fid:
-            kid2fid[b["kid"]] = fid
-        else:
-            unmapped.append(b["kid"])
-    print(f"kid -> fact_id: {len(kid2fid)} mapped onto {len(set(kid2fid.values()))} "
-          f"benchmark facts ({len(unmapped)} legacy kids fall outside the benchmark)")
-
-    def emit(fid, family, text, variant_id, language="en", template_id=None,
-             legacy=None, extra=None):
-        f = by_id[fid]
-        c = CONDS[family]
-        slot = c["target_slot"]
-        node = f["subject"] if slot == "subject" else f["object"]
-        rec = {
-            "query_id": None,                      # assigned after ordering
-            "fact_id": fid,
-            "relation": f["relation"]["relation_id"],
-            "condition_family": family,
-            "variant_id": variant_id,
-            "language": language,
-            "query": text,
-            "target_slot": slot,
-            "gold_canonical": node["canonical"],
-            "gold_aliases": node["aliases"],
-            "answer_type": f["answer_type"],
-            "answer_granularity": f["answer_granularity"],
-            "is_assisted": bool(c["is_assisted"]),
-            "is_well_posed": bool(c["is_well_posed"]),
-            "use_for_main_forward": bool(c["use_for_main_forward"]),
-            "use_for_reverse_analysis": bool(c["use_for_reverse_analysis"]),
-            "use_for_recognition_analysis": bool(c["use_for_recognition_analysis"]),
-            "source_template_id": template_id,
-            "legacy_query_refs": legacy or [],
-            # propagated from the fact: the gold string is part of the subject
-            # name, so the query text contains it for reasons that have nothing
-            # to do with answer leakage introduced by the template
-            "answer_in_subject_surface": bool(f.get("answer_in_subject_surface")),
-        }
-        if extra:
-            rec.update(extra)
-        return rec
-
-    rows = collections.defaultdict(list)
-    seen = set()                       # spec 11 dedup key
-    stats = collections.Counter()
-
-    # ---- anchor (spec 9.1) ----
-    for f in facts:
-        rows["anchor"].append(
-            emit(f["fact_id"], "anchor", f["qualification_question"], "anchor",
-                 template_id=f"{f['relation']['relation_id']}_anchor"))
-        seen.add((f["fact_id"], normalize(f["qualification_question"]),
-                  "object", "anchor"))
-
-    # ---- migrated conditions ----
-    for path in sorted(glob.glob(f"{EVAL_LEGACY}/query*.jsonl")):
-        stem = os.path.basename(path)[:-len(".jsonl")]
-        base_family = FILE_FAMILY.get(stem)
-        if base_family is None:
-            continue
-        for q in read_jsonl(path):
-            stats["read"] += 1
-            fid = kid2fid.get(q["kid"])
-            if fid is None:
-                stats["out_of_benchmark"] += 1
-                continue
-            family = base_family
-            if q.get("fmt") == "mcq":
-                family = "recognition"                       # spec 9.3 / 9.7
-            elif family == "reverse" and not q.get("reverse_well_posed"):
-                family = "reverse_illposed"                  # spec 9.8
-
-            key = (fid, normalize(q["prompt"]), CONDS[family]["target_slot"], family)
-            if key in seen:
-                stats["duplicates_removed"] += 1
-                continue
-
-            # spec 9.4 / 13.9: an open-ended main query must not expose the gold.
-            # Two context queries in the legacy bank sampled a distractor entity
-            # that literally contains the answer ("... confuse X with Indian Act
-            # ..." where the gold is India). A gold occurrence that lies inside
-            # the SUBJECT mention is inherent to the fact and stays; anything
-            # surviving removal of the subject is a defect and is dropped.
-            if CONDS[family]["use_for_main_forward"] and not CONDS[family]["is_assisted"]:
-                f = by_id[fid]
-                nq = normalize(q["prompt"])
-                gold = normalize(f["object"]["canonical"])
-                subj = normalize(f["subject"]["canonical"])
-                if gold and gold in (nq.replace(subj, " ") if subj else nq):
-                    stats["dropped_gold_exposed"] += 1
-                    continue
-
-            seen.add(key)
-
-            extra = {}
-            if family == "recognition":
-                extra["options"] = q.get("options")
-                extra["correct_option"] = q.get("correct_option")
-            if q.get("dkind"):
-                extra["context_kind"] = q["dkind"]
-            rows[family].append(
-                emit(fid, family, q["prompt"],
-                     variant_id=(q.get("qid") or "").split("_")[-1] or "01",
-                     language=q.get("lang", "en"),
-                     template_id=q.get("template_id"),
-                     legacy=[{"kid": q["kid"], "qid": q.get("qid"), "file": stem}],
-                     extra=extra))
-            stats["kept"] += 1
-
-    # ---- assign ids, write ----
-    flat = []
-    per_cond = {}
-    for fam in ORDER:
-        rs = rows.get(fam, [])
-        per_cond[fam] = {"queries": len(rs), "facts": len({r["fact_id"] for r in rs})}
-        flat += rs
-    for i, r in enumerate(flat, 1):
-        r["query_id"] = f"query_{i:08d}"
-
-    path = out_path("evaluation_queries_44418.jsonl")
-    write_jsonl(path, flat)
-
-    # ---- expected-count checks (spec 10) ----
-    for fam in ORDER:
-        c = CONDS[fam]
-        exp.check(f"{fam}.queries", per_cond[fam]["queries"], c["expected_queries"])
-        exp.check(f"{fam}.facts", per_cond[fam]["facts"], c["expected_facts"])
-    exp.check("total_queries", len(flat), cond_cfg["totals"]["expected_total_queries"])
-    main_n = sum(per_cond[f]["queries"] for f in ORDER
-                 if CONDS[f]["use_for_main_forward"])
-    exp.check("main_forward_queries", main_n,
-              cond_cfg["totals"]["expected_main_forward_queries"])
-    exp.check("duplicates_removed", stats["duplicates_removed"],
-              cond_cfg["deduplication"]["expected_removed_during_migration"])
-
-    # ---- coverage report (spec 12) ----
-    all_ids = set(by_id)
-    coverage, missing = {}, {}
-    for fam in ORDER:
-        covered = {r["fact_id"] for r in rows.get(fam, [])}
-        coverage[fam] = len(covered)
-        if CONDS[fam]["use_for_main_forward"]:
-            miss = sorted(all_ids - covered)
-            if miss:
-                missing[fam] = miss
-    json.dump({"benchmark_facts": len(facts), **coverage,
-               "missing_by_condition": missing,
-               "note": "main-forward families should ideally cover all facts; "
-                       "missing ids are listed rather than imputed (spec 12)"},
-              open(out_path("coverage_report.json"), "w"),
-              indent=2, ensure_ascii=False)
-
-    exp.report("Stage IV counts")
-    print(f"\n{'condition':20s} {'queries':>9s} {'facts':>7s} {'role':>12s}")
-    print("-" * 52)
-    for fam in ORDER:
-        print(f"{fam:20s} {per_cond[fam]['queries']:9d} "
-              f"{per_cond[fam]['facts']:7d} {CONDS[fam]['role']:>12s}")
-    print("-" * 52)
-    print(f"{'TOTAL':20s} {len(flat):9d}")
-    print(f"{'main forward':20s} {main_n:9d}")
-    print(f"\nmigration: {dict(stats)}")
-    print(f"wrote -> {path}")
-
-    # A deviation listed in configs/eval_conditions.yaml:accepted_deviations has
-    # been investigated and written up in reconstruction_differences.md, so it
-    # must not abort the pipeline. Anything NOT listed still fails, which keeps a
-    # fresh regression from hiding behind a documented one.
-    accepted = {(d["check"], d["actual"], d["expected"]): d.get("ref")
-                for d in cond_cfg.get("accepted_deviations", [])}
-    unexpected = [d for d in exp.deviations
-                  if (d["name"], d["actual"], d["expected"]) not in accepted]
-    for d in exp.deviations:
-        ref = accepted.get((d["name"], d["actual"], d["expected"]))
-        if ref:
-            print(f"  accepted deviation [{ref}]: {d['name']} "
-                  f"{d['actual']} vs {d['expected']}")
-    if unexpected:
-        print(f"\nUNDOCUMENTED deviations: {[d['name'] for d in unexpected]}")
-        print("Investigate, then add them to configs/eval_conditions.yaml:"
-              "accepted_deviations and outputs/reconstruction_differences.md")
-
-    json.dump({"stage": "IV_query_bank", "per_condition": per_cond,
-               "total": len(flat), "main_forward": main_n,
-               "migration": dict(stats), "checks": exp.rows,
-               "accepted_deviations": [d for d in exp.deviations
-                                       if (d["name"], d["actual"], d["expected"]) in accepted],
-               "undocumented_deviations": unexpected},
-              open(out_path("stage4_report.json"), "w"), indent=2, ensure_ascii=False)
-    return 1 if unexpected else 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

ICLR dataset/runner/build_stats.py

@@ -1,142 +0,0 @@
-#!/usr/bin/env python
-"""outputs/dataset_statistics.json  (spec section 14.1)
-
-Aggregates every stage report plus the fact and query files into the single
-statistics document the specification asks for.
-"""
-import os, sys, json, glob, collections, statistics
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from common import load_config, out_path, read_jsonl, normalize
-
-
-def load_report(name):
-    p = out_path(name)
-    return json.load(open(p)) if os.path.exists(p) else {}
-
-
-def main():
-    facts = list(read_jsonl(out_path("benchmark_facts_2592.jsonl")))
-    enriched = list(read_jsonl(out_path("enriched_facts_6180.jsonl")))
-    cands = list(read_jsonl(out_path("candidate_known_8107.jsonl")))
-    queries = list(read_jsonl(out_path("evaluation_queries_44418.jsonl")))
-    cond_cfg = load_config("eval_conditions.yaml")
-    mdl_cfg = load_config("models.yaml")
-
-    by_id = {f["fact_id"]: f for f in facts}
-    per_fact_q = collections.Counter(q["fact_id"] for q in queries)
-    alias_counts = [len(f["object"]["aliases"]) for f in facts]
-    sub_alias_counts = [len(f["subject"]["aliases"]) for f in facts]
-
-    fam = collections.defaultdict(lambda: {"queries": 0, "facts": set()})
-    for q in queries:
-        fam[q["condition_family"]]["queries"] += 1
-        fam[q["condition_family"]]["facts"].add(q["fact_id"])
-
-    # recognition distractor statistics (spec 14.1)
-    rec = [q for q in queries if q["condition_family"] == "recognition"]
-    opt_sizes = collections.Counter(len(q.get("options") or []) for q in rec)
-    pos = collections.Counter(q.get("correct_option") for q in rec)
-
-    ml = [q for q in queries if q["condition_family"] == "multilingual"]
-
-    stats = {
-        "pipeline": {
-            "candidate_known": len(cands),
-            "enriched_facts": len(enriched),
-            "benchmark_facts": len(facts),
-            "evaluation_queries": len(queries),
-            "relations": len({f["relation"]["relation_id"] for f in facts}),
-        },
-        "counts_by_source": {
-            "candidates": dict(collections.Counter(c["source"] for c in cands)),
-            "enriched": dict(collections.Counter(e["sources"][0] for e in enriched)),
-            "benchmark": dict(collections.Counter(f["sources"][0] for f in facts)),
-        },
-        "counts_by_relation": dict(collections.Counter(
-            f["relation"]["relation_id"] for f in facts).most_common()),
-        "counts_by_answer_type": dict(collections.Counter(
-            f["answer_type"] for f in facts).most_common()),
-        "counts_by_condition_family": {
-            k: {"queries": v["queries"], "facts": len(v["facts"]),
-                "role": cond_cfg["conditions"][k]["role"]}
-            for k, v in sorted(fam.items())},
-        "query_variants_per_fact": {
-            "min": min(per_fact_q.values()), "max": max(per_fact_q.values()),
-            "median": statistics.median(per_fact_q.values()),
-            "mean": round(statistics.mean(per_fact_q.values()), 2)},
-        "alias_counts": {
-            "object": {"total": sum(alias_counts),
-                       "median": statistics.median(alias_counts),
-                       "mean": round(statistics.mean(alias_counts), 2),
-                       "facts_with_one_alias": sum(1 for a in alias_counts if a == 1)},
-            "subject": {"total": sum(sub_alias_counts),
-                        "median": statistics.median(sub_alias_counts)}},
-        "duplicates": {
-            "candidate_rows_that_are_exact_duplicates":
-                len(cands) - len({(c["subject"], c["relation"], c["object"], c["source"])
-                                  for c in cands}),
-            "groups_merged_during_enrichment":
-                load_report("stage2_report.json").get("merged_groups"),
-            "cross_source_groups":
-                load_report("stage2_report.json").get("cross_source_groups"),
-            "queries_removed_during_migration":
-                load_report("stage4_report.json").get("migration", {})
-                .get("duplicates_removed")},
-        "conflicts": {
-            "functional_conflicts_removed":
-                load_report("stage2_report.json").get("conflicts_removed", {}),
-            "queries_dropped_gold_exposed":
-                load_report("stage4_report.json").get("migration", {})
-                .get("dropped_gold_exposed", 0)},
-        "coverage": json.load(open(out_path("coverage_report.json")))
-            if os.path.exists(out_path("coverage_report.json")) else {},
-        "reverse": {
-            "well_posed_queries": fam["reverse"]["queries"],
-            "well_posed_facts": len(fam["reverse"]["facts"]),
-            "ill_posed_queries": fam["reverse_illposed"]["queries"],
-            "ill_posed_facts": len(fam["reverse_illposed"]["facts"]),
-            "benchmark_facts_flagged_inverse_well_posed":
-                sum(1 for f in facts if f["is_inverse_well_posed"])},
-        "recognition_distractors": {
-            "queries": len(rec),
-            "option_count_distribution": {str(k): v for k, v in opt_sizes.items()},
-            "correct_option_position": {str(k): v for k, v in sorted(pos.items())}},
-        "multilingual": {
-            "queries": len(ml),
-            "by_language": dict(collections.Counter(q["language"] for q in ml))},
-        "validity_flags": {
-            "answer_in_subject_surface": {
-                "facts": sum(1 for f in facts if f.get("answer_in_subject_surface")),
-                "share": round(sum(1 for f in facts
-                                   if f.get("answer_in_subject_surface")) / len(facts), 4),
-                "by_relation": dict(collections.Counter(
-                    f["relation"]["relation_id"] for f in facts
-                    if f.get("answer_in_subject_surface")).most_common()),
-                "note": "object string is literally contained in the subject name, "
-                        "so the query can be answered by copying rather than by "
-                        "retrieval; kept in the benchmark but flagged"},
-            "spec_6_2_flagged": {
-                "facts": sum(1 for f in facts if f.get("spec_6_2_flag")),
-                "by_relation": dict(collections.Counter(
-                    f["relation"]["relation_id"] for f in facts
-                    if f.get("spec_6_2_flag")).most_common())}},
-        "configuration": {
-            "filter_models": [m["name"] for m in mdl_cfg["filter_models"]],
-            "evaluated_models": [m["name"] for m in mdl_cfg["evaluated_models"]],
-            "generation": mdl_cfg["generation"]},
-        "stage_reports": {n: load_report(f"stage{n}_report.json")
-                          for n in ["1", "2", "3", "4"]},
-    }
-
-    json.dump(stats, open(out_path("dataset_statistics.json"), "w"),
-              indent=2, ensure_ascii=False)
-    print(json.dumps(stats["pipeline"], indent=2))
-    print("\nvalidity flags:")
-    print(json.dumps(stats["validity_flags"]["answer_in_subject_surface"],
-                     indent=2, ensure_ascii=False)[:600])
-    print(f"\nwrote -> {out_path('dataset_statistics.json')}")
-
-
-if __name__ == "__main__":
-    main()

ICLR dataset/runner/common.py

@@ -1,159 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Shared helpers: config loading, paths, normalization, checksums.
-
-Spec section 18 requires deterministic reruns through configuration files and
-checksums, so every stage loads its parameters from configs/ rather than from
-module-level constants.
-"""
-import os, re, json, glob, hashlib, unicodedata
-
-ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-CONFIGS = os.path.join(ROOT, "configs")
-OUTPUTS = os.path.join(ROOT, "outputs")
-DATASET = "/scratch/rds-fei-rsfm-rw/cshi0459/ICLR27/dataset"
-
-SEED = 20260101
-
-
-def load_config(name):
-    import yaml
-    with open(os.path.join(CONFIGS, name)) as f:
-        return yaml.safe_load(f)
-
-
-def out_path(*parts):
-    p = os.path.join(OUTPUTS, *parts)
-    os.makedirs(os.path.dirname(p), exist_ok=True)
-    return p
-
-
-def read_jsonl(path):
-    with open(path) as f:
-        for line in f:
-            line = line.strip()
-            if line:
-                yield json.loads(line)
-
-
-def write_jsonl(path, rows):
-    n = 0
-    with open(path, "w") as f:
-        for r in rows:
-            f.write(json.dumps(r, ensure_ascii=False) + "\n")
-            n += 1
-    return n
-
-
-def sha256(path, limit_mb=None):
-    """Checksum for auditability (spec 18). limit_mb hashes only a prefix, which
-    keeps multi-GB source files cheap while still detecting substitution."""
-    h = hashlib.sha256()
-    cap = None if limit_mb is None else limit_mb * 1024 * 1024
-    read = 0
-    with open(path, "rb") as f:
-        while True:
-            b = f.read(1 << 20)
-            if not b:
-                break
-            h.update(b)
-            read += len(b)
-            if cap and read >= cap:
-                break
-    return f"sha256:{h.hexdigest()}" + ("" if cap is None else f"(first{limit_mb}MB)")
-
-
-# ------------------------------------------------------------- normalization
-_QUOTES = "\"'`‘’“”«»"
-_DASHES = "‐‑‒–—―"
-_ARTICLES = re.compile(r"\b(the|a|an)\b")
-
-
-def normalize(text, drop_articles=True):
-    """Comparison form: NFKC, lowercase, punctuation to space, articles dropped.
-
-    Punctuation is replaced INTERNALLY so that token-boundary matching still
-    finds an entity that is followed by a comma. Aliases and generations go
-    through the identical function.
-    """
-    if not text:
-        return ""
-    t = unicodedata.normalize("NFKC", str(text))
-    t = "".join("-" if c in _DASHES else ("'" if c in _QUOTES else c) for c in t)
-    t = t.lower()
-    t = re.sub(r"[^\w\s]", " ", t, flags=re.UNICODE)
-    t = re.sub(r"\s+", " ", t).strip()
-    if drop_articles:
-        t = _ARTICLES.sub(" ", t)
-    return re.sub(r"\s+", " ", t).strip()
-
-
-def norm_key(text):
-    """Identity key for grouping (no article stripping, so 'The Who' stays)."""
-    return normalize(text, drop_articles=False)
-
-
-def dedup_aliases(seq, junk_re=None, min_chars=2, cap=16):
-    """Deduplicate case-insensitively, preserving order.
-
-    The first element is the canonical label and is always kept. Later entries
-    are dropped when they normalize to fewer than `min_chars` characters or hit
-    a junk pattern: crowd-sourced Wikidata alias lists contain single letters,
-    emoji and Wikipedia housekeeping titles, and a one-or-two character alias
-    would match almost any generation under containment scoring.
-    """
-    seen, out = set(), []
-    for i, a in enumerate(seq):
-        if a is None:
-            continue
-        a = str(a).strip()
-        if not a:
-            continue
-        k = a.lower()
-        if k in seen:
-            continue
-        if i > 0 or out:
-            if len(normalize(a)) < min_chars:
-                continue
-            if junk_re is not None and junk_re.search(a):
-                continue
-        seen.add(k)
-        out.append(a)
-        if len(out) >= cap:
-            break
-    return out
-
-
-def compile_junk(patterns):
-    return re.compile("|".join(f"(?:{p})" for p in patterns), re.I) if patterns else None
-
-
-# ---------------------------------------------------------------- reporting
-class Expect:
-    """Collects expected-vs-actual counts. Spec section 10 forbids silently
-    changing counts, so every deviation is recorded and surfaced."""
-
-    def __init__(self):
-        self.rows = []
-
-    def check(self, name, actual, expected, note=""):
-        ok = (expected is None) or (actual == expected)
-        self.rows.append({"name": name, "actual": actual, "expected": expected,
-                          "match": ok, "note": note})
-        return ok
-
-    @property
-    def deviations(self):
-        return [r for r in self.rows if not r["match"]]
-
-    def report(self, title="counts"):
-        print(f"\n{title}")
-        print(f"{'check':38s} {'actual':>10s} {'expected':>10s}  ok")
-        print("-" * 66)
-        for r in self.rows:
-            e = "-" if r["expected"] is None else r["expected"]
-            print(f"{r['name']:38s} {r['actual']:>10} {e:>10}  "
-                  f"{'yes' if r['match'] else 'NO'}")
-        if self.deviations:
-            print(f"\n{len(self.deviations)} deviation(s); "
-                  f"record them in outputs/reconstruction_differences.md")
-        return self.rows

ICLR dataset/runner/enrich_facts.py

@@ -1,305 +0,0 @@
-#!/usr/bin/env python
-"""Stage II -> outputs/enriched_facts_6180.jsonl  (spec section 5)
-
-  8,107 candidate rows
-     -> group by entity-aware (subject identity, relation)      spec 5.1
-     -> merge object identities, discard functional conflicts    spec 5.2
-     -> expand accepted-answer aliases                           spec 5.3
-     -> attach a canonical qualification question                spec 5.4
-     -> emit the nested enriched schema                          spec 5.5
-
-Grouping is deliberately CROSS-SOURCE: 1,036 (subject, relation) pairs appear in
-both CounterFact and LAMA-TREx. Kept apart they would put the identical
-qualification question into the benchmark twice, double-counting the fact and
-breaking sample independence.
-"""
-import os, re, sys, json, glob, argparse, collections
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from common import (DATASET, load_config, out_path, read_jsonl, write_jsonl,
-                    normalize, norm_key, dedup_aliases, compile_junk, Expect)
-import qual_templates as QT
-
-try:
-    import pandas as pd
-except ImportError:
-    pd = None
-
-EXPECTED_GROUPS = 6185
-EXPECTED_CONFLICTS = 5
-EXPECTED_ENRICHED = 6180
-
-
-# ------------------------------------------------------- source metadata maps
-def load_source_metadata(allow_missing_parquet=False):
-    """Entity ids and native alias lists, keyed by (source, subject, rel, object)."""
-    print("[1/5] loading entity ids and source-native aliases ...", flush=True)
-    obj_qid, sub_qid = {}, {}
-    gre_obj, gre_sub, pq_meta = {}, {}, {}
-    degraded = False
-
-    if pd is None:
-        if not allow_missing_parquet:
-            raise SystemExit(
-                "pandas is required to read the CounterFact parquet files "
-                "(spec 5.3 needs target_true.id). Activate the project venv.")
-        print("      WARNING: pandas missing -> CounterFact entity ids SKIPPED",
-              flush=True)
-        degraded = True
-    else:
-        for p in glob.glob(f"{DATASET}/counterfact/data/*.parquet"):
-            for rr in pd.read_parquet(p, columns=["requested_rewrite"])["requested_rewrite"]:
-                k = ("counterfact", rr["subject"], rr["relation_id"],
-                     rr["target_true"]["str"])
-                obj_qid[k] = rr["target_true"]["id"]
-
-    for f in glob.glob(f"{DATASET}/lama/data/TREx/*.jsonl"):
-        for d in read_jsonl(f):
-            k = ("lama_trex", d.get("sub_label"), d.get("predicate_id"),
-                 d.get("obj_label"))
-            obj_qid[k] = d.get("obj_uri")
-            sub_qid[k] = d.get("sub_uri")
-
-    for f in glob.glob(f"{DATASET}/lama/data/Google_RE/*.jsonl"):
-        for d in read_jsonl(f):
-            rid = (d.get("pred") or "").rstrip("/").split("/")[-1]
-            k = (d.get("sub_label") or d.get("sub"), rid,
-                 d.get("obj_label") or d.get("obj"))
-            gre_obj[k] = d.get("obj_aliases") or []
-            gre_sub[k] = d.get("sub_aliases") or []
-
-    p = f"{DATASET}/filter/popqa_meta.jsonl"
-    if os.path.exists(p):
-        for d in read_jsonl(p):
-            pq_meta[(d["subject"], d["relation"], d["object"])] = d
-
-    return obj_qid, sub_qid, gre_obj, gre_sub, pq_meta, degraded
-
-
-def load_wikidata_aliases(needed, path, cap):
-    """Spec 5.3: single filtered pass over the alias resource, never a full load."""
-    print(f"[2/5] single-pass scan of the alias resource for {len(needed)} qids ...",
-          flush=True)
-    out = {}
-    with open(path) as f:
-        for line in f:
-            i = line.find("\t")
-            if i < 0:
-                continue
-            q = line[:i]
-            if q in needed:
-                out[q] = line[i + 1:].rstrip("\n").split("\t")[:cap]
-    print(f"      resolved {len(out)}/{len(needed)}", flush=True)
-    return out
-
-
-# -------------------------------------------------------------------- main
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--candidates", default=out_path("candidate_known_8107.jsonl"))
-    ap.add_argument("--allow_missing_parquet", action="store_true")
-    args = ap.parse_args()
-
-    rel_cfg = load_config("relations.yaml")
-    src_cfg = load_config("source_templates.yaml")
-    alias_cfg = src_cfg["alias_resources"]
-    junk_re = compile_junk(alias_cfg.get("junk_patterns"))
-    cap = alias_cfg.get("max_aliases_per_entity", 16)
-    min_chars = alias_cfg.get("min_alias_chars", 2)
-
-    # relation metadata: relations.yaml is authoritative for benchmark relations,
-    # qual_templates.py supplies the rest so that every enriched fact has a
-    # question (spec 5.4)
-    rel_meta = {}
-    for r in rel_cfg["relations"]:
-        for pid in r["source_relations"]:
-            rel_meta[pid] = r
-    exp = Expect()
-
-    obj_qid, sub_qid, gre_obj, gre_sub, pq_meta, degraded = \
-        load_source_metadata(args.allow_missing_parquet)
-
-    rows = list(read_jsonl(args.candidates))
-    needed = set()
-    for d in rows:
-        k = (d["source"], d["subject"], d["relation"], d["object"])
-        for m in (obj_qid, sub_qid):
-            if m.get(k):
-                needed.add(m[k])
-    qid_alias = load_wikidata_aliases(
-        needed, os.path.join(DATASET, alias_cfg["wikidata_entity_aliases"]), cap)
-
-    def obj_alias_raw(d):
-        src, s, rid, o = d["source"], d["subject"], d["relation"], d["object"]
-        al = [o]
-        if src == "lama_googlere":
-            al += gre_obj.get((s, rid, o), [])
-        elif src == "popqa":
-            m = pq_meta.get((s, rid, o), {})
-            al += m.get("possible_answers", []) + m.get("o_aliases", [])
-        q = obj_qid.get((src, s, rid, o))
-        if q:
-            al += qid_alias.get(q, [])
-        return al
-
-    def sub_alias_raw(d):
-        src, s, rid, o = d["source"], d["subject"], d["relation"], d["object"]
-        al = [s]
-        if src == "lama_googlere":
-            al += gre_sub.get((s, rid, o), [])
-        elif src == "popqa":
-            al += pq_meta.get((s, rid, o), {}).get("s_aliases", [])
-        q = sub_qid.get((src, s, rid, o))
-        if q:
-            al += qid_alias.get(q, [])
-        return al
-
-    # ---- spec 5.1: entity-aware grouping ----
-    print("[3/5] grouping by (subject identity, relation) across sources ...",
-          flush=True)
-    groups = collections.OrderedDict()
-    for d in rows:
-        # prefer the entity id when the source provides one, else normalized text
-        sq = sub_qid.get((d["source"], d["subject"], d["relation"], d["object"]))
-        ident = sq or norm_key(d["subject"])
-        groups.setdefault((ident, d["relation"]), []).append(d)
-    # a subject with an id in one source and no id in another must not split into
-    # two groups: fold text-keyed groups into the id-keyed one where possible
-    text_to_id = {}
-    for (ident, rid), members in groups.items():
-        if str(ident).startswith("Q"):
-            for m in members:
-                text_to_id[(norm_key(m["subject"]), rid)] = (ident, rid)
-    merged = collections.OrderedDict()
-    for key, members in groups.items():
-        ident, rid = key
-        if not str(ident).startswith("Q"):
-            key = text_to_id.get((ident, rid), key)
-        merged.setdefault(key, []).extend(members)
-    groups = merged
-    exp.check("grouped_facts", len(groups), EXPECTED_GROUPS)
-
-    # ---- spec 5.2 / 5.3 / 5.4 ----
-    print("[4/5] merging objects, expanding aliases, attaching questions ...",
-          flush=True)
-    SRC_PRIORITY = ["lama_trex", "counterfact", "popqa",
-                    "lama_googlere", "lama_conceptnet"]
-    rep = {"conflicts": collections.Counter(), "no_template": collections.Counter(),
-           "cross_source_groups": 0, "merged_groups": 0}
-
-    facts = []
-    for (ident, rid), members in groups.items():
-        cfg = rel_meta.get(rid)
-        spec = QT.resolve(rid)
-        if cfg is None and spec is None:
-            rep["no_template"][rid] += len(members)
-            continue
-
-        is_functional = bool(cfg["is_functional"]) if cfg else (not spec["multi"])
-        srcs = sorted({m["source"] for m in members},
-                      key=lambda s: SRC_PRIORITY.index(s) if s in SRC_PRIORITY else 99)
-        primary = next(m for m in members if m["source"] == srcs[0])
-
-        objects, obj_ids = [], []
-        seen_o = set()
-        for m in members:
-            k = norm_key(m["object"])
-            if k not in seen_o:
-                seen_o.add(k)
-                objects.append(m["object"])
-                obj_ids.append(obj_qid.get((m["source"], m["subject"], rid, m["object"])))
-
-        # spec 5.2: a functional group holding incompatible object identities is
-        # an unanswerable question (two people sharing a name, or a historical vs
-        # modern referent). A MISSING entity id is not evidence of sameness, so
-        # every member must carry an id and all ids must agree to survive.
-        if is_functional and len(objects) > 1:
-            ids = set(obj_ids)
-            if None in ids or len(ids) != 1:
-                rep["conflicts"][rid] += 1
-                continue
-
-        if len(members) > 1:
-            rep["merged_groups"] += 1
-        if len(srcs) > 1:
-            rep["cross_source_groups"] += 1
-
-        obj_aliases = dedup_aliases(
-            [a for m in members for a in obj_alias_raw(m)], junk_re, min_chars, cap)
-        sub_aliases = dedup_aliases(
-            [a for m in members for a in sub_alias_raw(m)], junk_re, min_chars, cap)
-
-        question = (cfg["qualification"] if cfg else spec["q"]).format(
-            s=primary["subject"])
-        facts.append({
-            "_sort": (rid, norm_key(primary["subject"])),
-            "subject": {"canonical": primary["subject"],
-                        "entity_id": ident if str(ident).startswith("Q") else None,
-                        "aliases": sub_aliases},
-            "relation": {"relation_id": cfg["relation_id"] if cfg else rid,
-                         "canonical_name": cfg["relation_id"] if cfg else rid,
-                         "source_relations": [rid],
-                         "direction": cfg.get("direction", "forward") if cfg else "forward"},
-            "object": {"canonical": objects[0],
-                       "entity_id": obj_ids[0],
-                       "aliases": obj_aliases,
-                       "variant_surface_forms": objects},
-            "qualification_question": question,
-            "sources": srcs,
-            "source_records": [m["raw_id"] for m in members],
-            "legacy_refs": [m["legacy_ref"] for m in members],
-            "is_functional": is_functional,
-            "is_inverse_well_posed": bool(cfg["is_inverse_well_posed"]) if cfg else False,
-            "answer_type": cfg["answer_type"] if cfg else spec["type"],
-            "answer_granularity": (cfg["answer_granularity"] if cfg
-                                   else (spec["gran"] or "entity")),
-            "is_core_source": bool({"counterfact", "lama_trex", "popqa"} & set(srcs)),
-            "is_benchmark_relation": cfg is not None,
-            "spec_6_2_flag": (cfg or {}).get("spec_6_2_flag"),
-            # The object string is literally contained in the subject name
-            # ("Airbus A318" -> "Airbus"). Such a fact is answerable by copying a
-            # substring of the question, so it measures string manipulation
-            # rather than knowledge retrieval. Not dropped here -- spec 16
-            # forbids silently removing facts -- but flagged so every downstream
-            # analysis can report with and without them.
-            "answer_in_subject_surface": bool(
-                normalize(objects[0]) and
-                normalize(objects[0]) in normalize(primary["subject"])),
-        })
-
-    exp.check("functional_conflicts_removed", sum(rep["conflicts"].values()),
-              EXPECTED_CONFLICTS)
-    exp.check("enriched_facts", len(facts), EXPECTED_ENRICHED)
-    exp.check("merged_groups", rep["merged_groups"], 1771)
-    exp.check("cross_source_groups", rep["cross_source_groups"], 1036)
-
-    # ---- stable, deterministic fact ids (spec 6.3) ----
-    print("[5/5] assigning deterministic fact ids ...", flush=True)
-    facts.sort(key=lambda f: f.pop("_sort"))
-    for i, f in enumerate(facts, 1):
-        f["fact_id"] = f"fact_{i:06d}"
-    facts = [{"fact_id": f.pop("fact_id"), **f} for f in facts]
-
-    path = out_path("enriched_facts_6180.jsonl")
-    write_jsonl(path, facts)
-
-    exp.report("Stage II counts")
-    meta = {"stage": "II_enrichment",
-            "n_enriched": len(facts),
-            "grouped": len(groups),
-            "conflicts_removed": dict(rep["conflicts"]),
-            "no_template": dict(rep["no_template"]),
-            "merged_groups": rep["merged_groups"],
-            "cross_source_groups": rep["cross_source_groups"],
-            "per_source": dict(collections.Counter(f["sources"][0] for f in facts)),
-            "counterfact_entity_ids_skipped": degraded,
-            "checks": exp.rows}
-    json.dump(meta, open(out_path("stage2_report.json"), "w"),
-              indent=2, ensure_ascii=False)
-    print(f"\nwrote {len(facts)} enriched facts -> {path}")
-    print(f"  conflicts removed: {dict(rep['conflicts'])}")
-    return 1 if exp.deviations else 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

ICLR dataset/runner/eval_run.py

@@ -1,151 +0,0 @@
-#!/usr/bin/env python
-"""Stage VI -> outputs/evaluation/<model>.jsonl   [GPU]
-
-Runs the full evaluation query bank for ONE model. Same decoding configuration
-as anchor qualification (configs/models.yaml:generation) so that anchor and
-perturbation numbers are directly comparable -- a different max_new_tokens or a
-chat template on one side would turn a protocol difference into a fake
-stability effect.
-
-Anchor queries live in the bank too (condition_family == "anchor") and share
-their prompt string with qualification_run.py. They are regenerated here rather
-than copied so that every condition passes through one identical code path.
-
-Scoring is NOT done here: eval_score.py reads these generations on CPU, so the
-scorer can be revised without paying for GPU again.
-"""
-import os, sys, json, time, argparse, collections
-import torch
-from transformers import AutoModelForCausalLM, AutoTokenizer
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from common import load_config, out_path, read_jsonl
-
-PROMPT = "Question: {q}\nAnswer with only the shortest correct answer.\nAnswer:"
-
-
-def build_prompt(row):
-    """Anchor and the open-ended conditions get the standard instruction wrapper.
-
-    The perturbation queries carry their own surface form -- that IS the
-    perturbation -- so wrapping them in the anchor template would erase the
-    manipulation. They are passed through with a bare "Answer:" cue so the model
-    still knows a short answer is wanted.
-    """
-    fam = row["condition_family"]
-    if fam == "anchor":
-        return PROMPT.format(q=row["query"])
-    if fam == "recognition":
-        # candidates are already inside the query text
-        return f"{row['query']}\nAnswer:"
-    return f"{row['query']}\nAnswer:"
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--model", required=True, help="name from configs/models.yaml")
-    ap.add_argument("--queries", default=out_path("evaluation_queries_44418.jsonl"))
-    ap.add_argument("--conditions", nargs="*", default=None,
-                    help="restrict to these condition families (default: all)")
-    ap.add_argument("--limit", type=int, default=0)
-    ap.add_argument("--batch", type=int, default=0, help="0 = value from config")
-    ap.add_argument("--resume", action="store_true",
-                    help="skip queries already present in the output file")
-    args = ap.parse_args()
-
-    cfg = load_config("models.yaml")
-    entry = next((m for m in cfg["evaluated_models"] if m["name"] == args.model), None)
-    if entry is None:
-        raise SystemExit(f"{args.model} is not in configs/models.yaml:evaluated_models")
-    gen_cfg = cfg["generation"]
-    if gen_cfg.get("use_chat_template"):
-        raise SystemExit("spec 7.2: base and instruct models must share the raw "
-                         "prompt string; chat templates are not applied")
-
-    rows = list(read_jsonl(args.queries))
-    if args.conditions:
-        rows = [r for r in rows if r["condition_family"] in args.conditions]
-    if args.limit:
-        rows = rows[:args.limit]
-
-    dest = out_path("evaluation", f"{args.model}.jsonl")
-    done = set()
-    if args.resume and os.path.exists(dest):
-        done = {r["query_id"] for r in read_jsonl(dest)}
-        rows = [r for r in rows if r["query_id"] not in done]
-        print(f"[{args.model}] resuming: {len(done)} already done", flush=True)
-    if not rows:
-        print(f"[{args.model}] nothing to do")
-        return
-
-    N = len(rows)
-    fam_counts = collections.Counter(r["condition_family"] for r in rows)
-    print(f"[{args.model}] N={N}  {dict(fam_counts)}", flush=True)
-
-    path = os.path.join(cfg["model_root"], entry["path"])
-    torch.manual_seed(gen_cfg.get("seed", 0))
-    tok = AutoTokenizer.from_pretrained(path)
-    if tok.pad_token is None:
-        tok.pad_token = tok.eos_token
-    tok.padding_side = "left"
-    tok.truncation_side = "left"
-    model = AutoModelForCausalLM.from_pretrained(
-        path, dtype=getattr(torch, gen_cfg.get("dtype", "bfloat16")),
-        device_map={"": 0}).eval()
-
-    prompts = [build_prompt(r) for r in rows]
-    # context queries prepend distractor sentences, so they are much longer than
-    # the anchor; a single global max_len would silently truncate them
-    max_len = max(gen_cfg.get("max_prompt_len", 96), 192)
-    B = args.batch or gen_cfg.get("batch_size", 96)
-
-    out = [None] * N
-    order = sorted(range(N), key=lambda i: len(prompts[i]))
-    t0 = time.time()
-    with torch.no_grad():
-        for b in range(0, N, B):
-            idx = order[b:b + B]
-            enc = tok([prompts[i] for i in idx], return_tensors="pt", padding=True,
-                      truncation=True, max_length=max_len).to(0)
-            plen = enc["input_ids"].shape[1]
-            gen = model.generate(**enc,
-                                 max_new_tokens=gen_cfg.get("max_new_tokens", 24),
-                                 do_sample=gen_cfg.get("do_sample", False),
-                                 num_beams=gen_cfg.get("num_beams", 1),
-                                 pad_token_id=tok.pad_token_id)
-            new_ids = gen[:, plen:]
-            texts = tok.batch_decode(new_ids, skip_special_tokens=True)
-            for j, i in enumerate(idx):
-                ids = new_ids[j].tolist()
-                n_tok, fin = len(ids), "length"
-                for k, t in enumerate(ids):
-                    if t == tok.eos_token_id:
-                        n_tok, fin = k, "eos"
-                        break
-                out[i] = {"query_id": rows[i]["query_id"],
-                          "fact_id": rows[i]["fact_id"],
-                          "condition_family": rows[i]["condition_family"],
-                          "model": args.model,
-                          "prompt": prompts[i],
-                          "raw_response": texts[j],
-                          "generated_tokens": int(n_tok),
-                          "finish_reason": fin}
-            if b % (B * 20) == 0:
-                d = b + len(idx)
-                print(f"  {d}/{N}  {d / max(time.time() - t0, 1e-9):.1f}/s", flush=True)
-
-    mode = "a" if (args.resume and done) else "w"
-    with open(dest, mode) as f:
-        for r in out:
-            f.write(json.dumps(r, ensure_ascii=False) + "\n")
-    json.dump({"model": args.model, "n_generated": N, "resumed_from": len(done),
-               "generation": gen_cfg, "max_prompt_len": max_len,
-               "model_entry": entry, "seconds": round(time.time() - t0, 1),
-               "by_condition": dict(fam_counts)},
-              open(out_path("evaluation", f"{args.model}.meta.json"), "w"),
-              indent=2, ensure_ascii=False)
-    print(f"[{args.model}] wrote {N} -> {dest}  ({time.time() - t0:.0f}s)  EVAL_DONE")
-
-
-if __name__ == "__main__":
-    main()

ICLR dataset/runner/eval_score.py

@@ -1,207 +0,0 @@
-#!/usr/bin/env python
-"""Stage VI scoring -> outputs/evaluation/<model>.scored.jsonl
-                       outputs/stability_report.json
-
-Reads the stored generations on CPU and produces the stability numbers.
-
-Three reporting rules, all enforced here rather than left to the reader:
-
-  * conditions are grouped by the booleans carried on each query, which come
-    from configs/eval_conditions.yaml. `recognition` and `reverse_illposed`
-    never enter a main-forward average, and `reverse` is reported separately
-    because it changes the target slot (spec 2.3 / 16).
-
-  * two denominators are always reported side by side:
-        fixed     all 2,592 benchmark facts            (spec 2.1)
-        anchored  restricted to K_m for that model     conditional retention
-    The fixed one is the benchmark score; the anchored one answers "of the
-    facts this model demonstrably knows, how many survive the perturbation".
-
-  * every number is split by `answer_in_subject_surface`, because 28.9% of the
-    benchmark can be answered by copying a substring of the question and those
-    facts are near-ceiling stable for reasons unrelated to knowledge
-    (outputs/reconstruction_differences.md F1).
-"""
-import os, sys, json, glob, argparse, collections
-import numpy as np
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from common import load_config, out_path, read_jsonl, write_jsonl, normalize
-from scoring_full import score, needs_manual_review
-
-import re
-MCQ_LETTER = re.compile(r"^\s*[\(\[]?([A-Da-d])[\)\]\.:,\s]")
-
-
-def score_recognition(raw, row):
-    """MCQ: accept either the option letter or the option text."""
-    m = MCQ_LETTER.match((raw or "") + " ")
-    if m and row.get("correct_option"):
-        ok = m.group(1).upper() == str(row["correct_option"]).upper()
-        return {"label": "correct" if ok else "incorrect",
-                "matched_alias": m.group(1).upper(), "scorer": "mcq_letter",
-                "span": (raw or "").strip()[:40], "flags": []}
-    return score(raw, row["gold_aliases"], answer_type=row["answer_type"],
-                 granularity=row.get("answer_granularity"))
-
-
-def bootstrap_ci(values, groups, n_boot=2000, seed=0, alpha=0.05):
-    """Cluster bootstrap over relations; the relation mix is heavily skewed."""
-    rng = np.random.default_rng(seed)
-    by = collections.defaultdict(list)
-    for v, g in zip(values, groups):
-        by[g].append(v)
-    keys = list(by)
-    if not keys:
-        return (float("nan"), float("nan"))
-    arrs = [np.asarray(by[k], dtype=float) for k in keys]
-    st = np.empty(n_boot)
-    for b in range(n_boot):
-        pick = rng.integers(0, len(keys), len(keys))
-        st[b] = np.concatenate([arrs[i] for i in pick]).mean()
-    return float(np.quantile(st, alpha / 2)), float(np.quantile(st, 1 - alpha / 2))
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--queries", default=out_path("evaluation_queries_44418.jsonl"))
-    ap.add_argument("--facts", default=out_path("benchmark_facts_2592.jsonl"))
-    ap.add_argument("--models", nargs="*", default=None)
-    args = ap.parse_args()
-
-    cond_cfg = load_config("eval_conditions.yaml")["conditions"]
-    queries = {q["query_id"]: q for q in read_jsonl(args.queries)}
-    facts = {f["fact_id"]: f for f in read_jsonl(args.facts)}
-
-    known_path = out_path("known_labels.json")
-    known = json.load(open(known_path))["labels"] if os.path.exists(known_path) else {}
-    if not known:
-        print("WARNING: outputs/known_labels.json missing -> anchored (K_m) "
-              "numbers will be omitted. Run qualification_score.py first.")
-
-    edir = os.path.dirname(out_path("evaluation", "x"))
-    paths = sorted(p for p in glob.glob(os.path.join(edir, "*.jsonl"))
-                   if not p.endswith(".scored.jsonl"))
-    if args.models:
-        paths = [p for p in paths
-                 if os.path.basename(p)[:-len(".jsonl")] in args.models]
-    if not paths:
-        raise SystemExit(f"no generation files in {edir}; run eval_run.py first")
-
-    report = {"models": {}, "denominators": {
-        "fixed": "all benchmark facts (spec 2.1)",
-        "anchored": "facts whose anchor label is `correct` for that model (K_m)"}}
-
-    for p in paths:
-        model = os.path.basename(p)[:-len(".jsonl")]
-        km = {fid for fid, lab in known.items() if lab.get(model) == "correct"}
-        scored = []
-        # cond -> bucket -> list of (correct, relation)
-        acc = collections.defaultdict(lambda: collections.defaultdict(list))
-        labels = collections.defaultdict(collections.Counter)
-
-        for g in read_jsonl(p):
-            q = queries.get(g["query_id"])
-            if q is None:
-                raise SystemExit(f"{model}: generation for unknown query "
-                                 f"{g['query_id']}")
-            fam = q["condition_family"]
-            r = (score_recognition(g["raw_response"], q) if fam == "recognition"
-                 else score(g["raw_response"], q["gold_aliases"],
-                            answer_type=q["answer_type"],
-                            granularity=q.get("answer_granularity")))
-            ok = 1.0 if r["label"] == "correct" else 0.0
-            copy_flag = bool(q.get("answer_in_subject_surface"))
-            rel = q["relation"]
-
-            rec = {"query_id": q["query_id"], "fact_id": q["fact_id"],
-                   "model": model, "condition_family": fam,
-                   "language": q.get("language", "en"),
-                   "target_slot": q["target_slot"],
-                   "raw_response": g["raw_response"],
-                   "extracted_answer": r["span"], "label": r["label"],
-                   "matched_alias": r["matched_alias"], "scorer": r["scorer"],
-                   "relation": rel, "answer_type": q["answer_type"],
-                   "answer_in_subject_surface": copy_flag,
-                   "in_K_m": q["fact_id"] in km,
-                   "use_for_main_forward": q["use_for_main_forward"],
-                   "manual_review": needs_manual_review(r)}
-            scored.append(rec)
-            labels[fam][r["label"]] += 1
-
-            acc[fam]["fixed"].append((ok, rel))
-            acc[fam]["fixed_copy" if copy_flag else "fixed_real"].append((ok, rel))
-            if q["fact_id"] in km:
-                acc[fam]["anchored"].append((ok, rel))
-                acc[fam]["anchored_copy" if copy_flag else "anchored_real"].append((ok, rel))
-
-        write_jsonl(os.path.join(edir, f"{model}.scored.jsonl"), scored)
-
-        def stat(pairs):
-            if not pairs:
-                return None
-            v = [x for x, _ in pairs]
-            g = [r for _, r in pairs]
-            lo, hi = bootstrap_ci(v, g)
-            return {"acc": round(float(np.mean(v)), 4), "n": len(v),
-                    "ci95_relation_clustered": [round(lo, 4), round(hi, 4)]}
-
-        per_cond = {}
-        for fam, buckets in acc.items():
-            per_cond[fam] = {
-                "role": cond_cfg[fam]["role"],
-                "use_for_main_forward": cond_cfg[fam]["use_for_main_forward"],
-                "labels": dict(labels[fam]),
-                **{b: stat(v) for b, v in buckets.items()}}
-
-        main_fams = [f for f in per_cond if cond_cfg[f]["use_for_main_forward"]
-                     and f != "anchor"]
-        def macro(bucket):
-            vals = [per_cond[f][bucket]["acc"] for f in main_fams
-                    if per_cond[f].get(bucket)]
-            return round(float(np.mean(vals)), 4) if vals else None
-
-        report["models"][model] = {
-            "K_m": len(km),
-            "per_condition": per_cond,
-            "main_forward_macro": {
-                "fixed": macro("fixed"), "anchored": macro("anchored"),
-                "anchored_real": macro("anchored_real"),
-                "anchored_copy": macro("anchored_copy"),
-                "note": "mean over paraphrase/format/context/multilingual; "
-                        "anchor excluded (it is the baseline), reverse excluded "
-                        "(different target slot), recognition and "
-                        "reverse_illposed excluded (diagnostics)"},
-            "n_manual_review": sum(1 for r in scored if r["manual_review"]),
-        }
-
-    json.dump(report, open(out_path("stability_report.json"), "w"),
-              indent=2, ensure_ascii=False)
-
-    # ---------------------------------------------------------------- console
-    order = ["anchor", "paraphrase", "format", "context", "multilingual",
-             "reverse", "recognition", "reverse_illposed"]
-    for model, m in report["models"].items():
-        print(f"\n=== {model}   K_m={m['K_m']} ===")
-        print(f"{'condition':18s} {'fixed':>7s} {'anchored':>9s} "
-              f"{'  ·real':>8s} {'  ·copy':>8s} {'n':>7s}  role")
-        print("-" * 70)
-        for fam in order:
-            c = m["per_condition"].get(fam)
-            if not c:
-                continue
-            def g(b):
-                return f"{c[b]['acc']:.3f}" if c.get(b) else "    -"
-            print(f"{fam:18s} {g('fixed'):>7s} {g('anchored'):>9s} "
-                  f"{g('anchored_real'):>8s} {g('anchored_copy'):>8s} "
-                  f"{c['fixed']['n']:7d}  {c['role']}")
-        mm = m["main_forward_macro"]
-        print(f"{'MAIN macro':18s} {str(mm['fixed']):>7s} {str(mm['anchored']):>9s} "
-              f"{str(mm['anchored_real']):>8s} {str(mm['anchored_copy']):>8s}")
-    print("\n·real / ·copy split the anchored numbers by whether the answer is "
-          "contained in the subject name (see reconstruction_differences.md F1)")
-    print(f"\nwrote -> {out_path('stability_report.json')}")
-
-
-if __name__ == "__main__":
-    main()

ICLR dataset/runner/filter_run.py

@@ -1,109 +0,0 @@
-#!/usr/bin/env python
-"""Stage I first-token candidate filtering for ONE model (spec section 4.4) [GPU]
-
-Regenerates the per-prompt verdict vector that build_candidate_known.py consumes.
-The stored vectors under dataset/filter/ were produced by an equivalent script;
-this one is config-driven per spec 4.4 and writes the richer per-prompt record
-the specification asks for.
-
-Protocol, unchanged from the original run so the vectors stay comparable:
-  1. tokenize the cloze prompt
-  2. take the logits at the final prompt position
-  3. take the argmax token
-  4. compare with the first token of " " + object
-  5. record pass / fail
-
-This is candidate RECALL only. Spec 4.4: a pass here is not a correctness
-judgment, and spec 16 forbids treating first-token correctness as full-answer
-correctness.
-"""
-import os, sys, json, time, argparse
-import numpy as np
-import torch
-from transformers import AutoModelForCausalLM, AutoTokenizer
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from common import DATASET, load_config, out_path, read_jsonl
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--model", required=True, help="name from configs/models.yaml")
-    ap.add_argument("--prompts", default=os.path.join(DATASET, "filter/prompts.jsonl"))
-    ap.add_argument("--out_dir", default=None)
-    ap.add_argument("--batch", type=int, default=384)
-    ap.add_argument("--max_len", type=int, default=64)
-    ap.add_argument("--limit", type=int, default=0)
-    ap.add_argument("--save_records", action="store_true",
-                    help="also write the per-prompt JSONL of spec 4.4; large")
-    args = ap.parse_args()
-
-    cfg = load_config("models.yaml")
-    entry = next((m for m in cfg["filter_models"] if m["name"] == args.model), None)
-    if entry is None:
-        raise SystemExit(f"{args.model} is not in configs/models.yaml:filter_models")
-    path = os.path.join(cfg["model_root"], entry["path"])
-    out_dir = args.out_dir or out_path("filter_outputs", "x")[:-1]
-    os.makedirs(out_dir, exist_ok=True)
-
-    prompts, objects = [], []
-    ids = []
-    for d in read_jsonl(args.prompts):
-        prompts.append(d["prompt"])
-        objects.append(d["object"])
-        ids.append(d["id"])
-        if args.limit and len(prompts) >= args.limit:
-            break
-    N = len(prompts)
-    print(f"[{args.model}] N={N}", flush=True)
-
-    tok = AutoTokenizer.from_pretrained(path)
-    if tok.pad_token is None:
-        tok.pad_token = tok.eos_token
-    tok.padding_side = "left"
-    tok.truncation_side = "left"      # keep the END of the prompt, the cloze cue
-    model = AutoModelForCausalLM.from_pretrained(
-        path, dtype=torch.bfloat16, device_map={"": 0}).eval()
-
-    gold_first = np.empty(N, dtype=np.int64)
-    for i, o in enumerate(objects):
-        t = tok(" " + o, add_special_tokens=False).input_ids
-        gold_first[i] = t[0] if t else -1
-
-    passed = np.zeros(N, dtype=np.uint8)
-    pred_ids = np.zeros(N, dtype=np.int64)
-    order = sorted(range(N), key=lambda i: len(prompts[i]))
-    t0 = time.time()
-    with torch.no_grad():
-        for b in range(0, N, args.batch):
-            idx = order[b:b + args.batch]
-            enc = tok([prompts[i] for i in idx], return_tensors="pt", padding=True,
-                      truncation=True, max_length=args.max_len).to(0)
-            pred = model(**enc).logits[:, -1, :].argmax(-1).cpu().numpy()
-            for j, i in enumerate(idx):
-                pred_ids[i] = pred[j]
-                passed[i] = int(pred[j] == gold_first[i])
-            if b % (args.batch * 200) == 0:
-                done = b + len(idx)
-                el = max(time.time() - t0, 1e-9)
-                print(f"  {done}/{N}  {done / el:.0f} ex/s  "
-                      f"pass={passed[:done].mean():.4f}", flush=True)
-
-    np.save(os.path.join(out_dir, f"correct_{args.model}.npy"), passed)
-    if args.save_records:
-        with open(os.path.join(out_dir, f"records_{args.model}.jsonl"), "w") as f:
-            for i in range(N):
-                f.write(json.dumps({
-                    "prompt_id": ids[i], "model": args.model,
-                    "predicted_token_id": int(pred_ids[i]),
-                    "predicted_token_text": tok.decode([int(pred_ids[i])]),
-                    "gold_token_id": int(gold_first[i]),
-                    "gold_token_text": tok.decode([int(gold_first[i])])
-                                       if gold_first[i] >= 0 else "",
-                    "passed": bool(passed[i])}, ensure_ascii=False) + "\n")
-    print(f"[{args.model}] pass rate={passed.mean():.4f}  "
-          f"({time.time() - t0:.0f}s)  FILTER_DONE", flush=True)
-
-
-if __name__ == "__main__":
-    main()

ICLR dataset/runner/qual_templates.py

@@ -1,122 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Qualification-only question templates.
-
-DELIBERATELY SEPARATE from dataset/filter/rel_templates.py: the qualification
-question must not be one of the eval-condition paraphrases, otherwise a fact
-qualifies on exactly the phrasing that is later scored as a "perturbation" and
-the stability measurement leaks.  Every `q` below is checked against the eval
-canonical/paraphrase set by validate_facts.py.
-
-Per relation:
-  q      qualification question, slot {s}; answer = object
-  type   answer_type (drives the scorer and the per-type reporting breakdown)
-  gran   answer_granularity, only meaningful for date/number types
-  multi  relation is inherently multi-answer (an entity can have several
-         equally correct objects) -> facts get is_multi_answer=True even when
-         the candidate pool happens to contain only one object
-"""
-
-# answer_type vocabulary (keep closed; validate_facts.py enforces it)
-TYPES = {"person", "place", "city", "country", "language", "organization",
-         "occupation", "sport", "instrument", "genre", "religion", "color",
-         "year", "date", "entity", "concept", "action", "property"}
-
-QUAL = {
- # ---- language ----
- "P103":  dict(q="Which language did {s} grow up speaking?",            type="language", multi=False),
- "P1412": dict(q="Which language is {s} able to speak?",                type="language", multi=True),
- "P37":   dict(q="Which language has official status in {s}?",          type="language", multi=True),
- "P364":  dict(q="In which language was {s} originally produced?",      type="language", multi=True),
- "P407":  dict(q="Which language is {s} written in?",                   type="language", multi=True),
- # ---- geography ----
- "P36":   dict(q="Which city is the seat of government of {s}?",        type="city",     multi=False),
- "P1376": dict(q="{s} is the capital city of which country?",           type="country",  multi=False),
- "P17":   dict(q="Which country does {s} belong to?",                   type="country",  multi=False),
- "P27":   dict(q="Which country holds {s}'s citizenship?",              type="country",  multi=True),
- "P30":   dict(q="Which continent is {s} part of?",                     type="place",    multi=False),
- "P131":  dict(q="Which administrative region contains {s}?",           type="place",    multi=False),
- "P276":  dict(q="At which location can {s} be found?",                 type="place",    multi=False),
- "P19":   dict(q="In which place did {s} come into the world?",         type="city",     multi=False),
- "P20":   dict(q="At which place did {s} pass away?",                   type="city",     multi=False),
- "P159":  dict(q="Which city hosts the main offices of {s}?",                 type="city",     multi=False),
- "P190":  dict(q="{s} maintains a twin-town relationship with which city?",                     type="city",     multi=True),
- "P47":   dict(q="Which territory lies adjacent to {s}?",               type="place",    multi=True),
- "P495":  dict(q="Which country did {s} originate from?",               type="country",  multi=False),
- "P740":  dict(q="{s} came into existence in which place?",                     type="city",     multi=False),
- "P937":  dict(q="In which place did {s} carry out their work?",        type="city",     multi=True),
- "P1001": dict(q="Which jurisdiction does {s} have legal force in?",    type="place",    multi=False),
- # ---- people / organizations ----
- "P178":  dict(q="Which company or person created {s}?",                type="organization", multi=False),
- "P176":  dict(q="Which company builds {s}?",                           type="organization", multi=False),
- "P127":  dict(q="Who is the owner of {s}?",                            type="organization", multi=False),
- "P108":  dict(q="For which organization does {s} work?",               type="organization", multi=True),
- "P463":  dict(q="{s} holds membership in which organization?",         type="organization", multi=True),
- "P449":  dict(q="Which network first broadcast {s}?",                  type="organization", multi=False),
- "P264":  dict(q="Under which record label is {s} signed?",             type="organization", multi=True),
- "P22":   dict(q="{s} is the child of which father?",                   type="person",   multi=False),
- "P25":   dict(q="{s} is the child of which mother?",                   type="person",   multi=False),
- "P50":   dict(q="Which writer wrote {s}?",                             type="person",   multi=True),
- "P57":   dict(q="Which filmmaker directed {s}?",                       type="person",   multi=True),
- "P58":   dict(q="Which writer wrote the screenplay for {s}?",          type="person",   multi=True),
- "P86":   dict(q="Which composer wrote the music for {s}?",             type="person",   multi=True),
- "P162":  dict(q="Which person produced {s}?",                          type="person",   multi=True),
- # ---- attributes ----
- "P106":  dict(q="Which profession is {s} known for?",                      type="occupation", multi=True),
- "P101":  dict(q="Which subject area is {s} known for working on?",     type="concept",  multi=True),
- "P641":  dict(q="Which sport is {s} associated with?",                 type="sport",    multi=False),
- "P413":  dict(q="On the field, which position is {s} assigned to?",    type="occupation", multi=False),
- "P1303": dict(q="Which musical instrument does {s} perform on?",       type="instrument", multi=True),
- "P136":  dict(q="Which genre does {s} fall under?",                    type="genre",    multi=True),
- "P140":  dict(q="Which faith does {s} follow?",                        type="religion", multi=False),
- "P462":  dict(q="Which colour does {s} have?",                         type="color",    multi=True),
- "P31":   dict(q="{s} is an example of what kind of thing?",            type="concept",  multi=True),
- "P279":  dict(q="{s} is a more specific kind of what?",                type="concept",  multi=True),
- "P527":  dict(q="Which component does {s} contain?",                   type="entity",   multi=True),
-
- # ---- Google_RE (extension set) ----
- "date_of_birth":  dict(q="In which year was {s} born?",                type="year",  gran="year",  multi=False),
- "place_of_birth": dict(q="In which place did {s} come into the world?", type="city",  multi=False),
- "place_of_death": dict(q="At which place did {s} pass away?",          type="city",  multi=False),
-
- # ---- ConceptNet (open-ended extension set; all inherently multi-answer) ----
- "IsA":             dict(q="Which category does {s} belong to?",                     type="concept",  multi=True),
- "UsedFor":         dict(q="People use {s} in order to do what?",                          type="action",   multi=True),
- "AtLocation":      dict(q="In what sort of place does {s} normally sit?",            type="place",    multi=True),
- "HasA":            dict(q="Which part does {s} come with?",                            type="entity",   multi=True),
- "HasProperty":     dict(q="Which characteristic applies to {s}?",                   type="property", multi=True),
- "CapableOf":       dict(q="What is {s} able to do?",                        type="action",   multi=True),
- "PartOf":          dict(q="Which larger whole includes {s}?",                         type="entity",   multi=True),
- "Causes":          dict(q="Which outcome follows from {s}?",                           type="action",   multi=True),
- "CausesDesire":    dict(q="After {s}, what urge follows?",             type="action",   multi=True),
- "Desires":         dict(q="Which thing does {s} wish for?",                            type="action",   multi=True),
- "NotDesires":      dict(q="Which thing would {s} rather avoid?",                        type="action",   multi=True),
- "HasSubevent":     dict(q="What happens as part of {s}?",                   type="action",   multi=True),
- "HasPrerequisite": dict(q="What has to happen before {s}?",                 type="action",   multi=True),
- "MotivatedByGoal": dict(q="Why would someone do {s}?",                      type="action",   multi=True),
- "MadeOf":          dict(q="What material is {s} made of?",                  type="entity",   multi=True),
- "ReceivesAction":  dict(q="Which action is commonly performed on {s}?",                       type="action",   multi=True),
-}
-
-# instruction appended to every qualification prompt (no candidates shown, so
-# this stays free generation; it only suppresses explanatory prose)
-INSTRUCTION = "Answer with only the shortest correct answer."
-
-
-def resolve(rid):
-    """Spec for a relation id, or None when the relation has no template.
-
-    No generic fallback on purpose: a fact whose relation lacks a hand-written
-    natural question would get an awkward auto-verbalization, and a wrong
-    qualification question silently shrinks the Known Set. Such facts are
-    dropped by enrich_facts.py and counted in the report.
-    """
-    spec = QUAL.get(rid)
-    if spec is None:
-        return None
-    return {"q": spec["q"], "type": spec["type"],
-            "gran": spec.get("gran"), "multi": spec.get("multi", False)}
-
-
-def build_prompt(question, instruction=INSTRUCTION):
-    """Plain-completion qualification prompt (see README for why not chat)."""
-    return f"Question: {question}\n{instruction}\nAnswer:"

ICLR dataset/runner/qualification_run.py

@@ -1,135 +0,0 @@
-#!/usr/bin/env python
-"""Stage V -> outputs/qualification/<model>.jsonl  (spec section 7) [GPU]
-
-Anchor qualification: does this model answer the canonical question correctly?
-
-Spec 7.1: the result is a LABEL. It never removes a fact from the benchmark, so
-the denominator stays at 2,592 for every model and adding a model later cannot
-change any previously computed number.
-
-Spec 7.2: identical raw prompt string for base and instruction-tuned models, no
-chat template, no candidates, no few-shot.
-Spec 7.3: greedy decoding, max_new_tokens 24, everything stored.
-"""
-import os, sys, json, time, argparse
-import torch
-from transformers import AutoModelForCausalLM, AutoTokenizer
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from common import load_config, out_path, read_jsonl
-
-PROMPT = "Question: {q}\nAnswer with only the shortest correct answer.\nAnswer:"
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--model", required=True, help="name from configs/models.yaml")
-    ap.add_argument("--facts", default=out_path("benchmark_facts_2592.jsonl"))
-    ap.add_argument("--limit", type=int, default=0)
-    ap.add_argument("--save_logprob", action="store_true",
-                    help="one extra teacher-forced pass for the gold sequence score")
-    args = ap.parse_args()
-
-    cfg = load_config("models.yaml")
-    entry = next((m for m in cfg["evaluated_models"] if m["name"] == args.model), None)
-    if entry is None:
-        raise SystemExit(f"{args.model} is not in configs/models.yaml:evaluated_models")
-    gen_cfg = cfg["generation"]
-    if gen_cfg.get("use_chat_template"):
-        raise SystemExit("spec 7.2 forbids a chat template in anchor qualification")
-
-    path = os.path.join(cfg["model_root"], entry["path"])
-    facts = list(read_jsonl(args.facts))
-    if args.limit:
-        facts = facts[:args.limit]
-    N = len(facts)
-    print(f"[{args.model}] N={N}  revision={entry.get('revision')}", flush=True)
-
-    torch.manual_seed(gen_cfg.get("seed", 0))
-    tok = AutoTokenizer.from_pretrained(path)
-    if tok.pad_token is None:
-        tok.pad_token = tok.eos_token
-    tok.padding_side = "left"
-    tok.truncation_side = "left"
-    model = AutoModelForCausalLM.from_pretrained(
-        path, dtype=getattr(torch, gen_cfg.get("dtype", "bfloat16")),
-        device_map={"": 0}).eval()
-
-    prompts = [PROMPT.format(q=f["qualification_question"]) for f in facts]
-    golds = [f["object"]["canonical"] for f in facts]
-    gold_ids = [tok(" " + g, add_special_tokens=False).input_ids for g in golds]
-
-    out = [None] * N
-    order = sorted(range(N), key=lambda i: len(prompts[i]))
-    B = gen_cfg.get("batch_size", 96)
-    t0 = time.time()
-
-    with torch.no_grad():
-        for b in range(0, N, B):
-            idx = order[b:b + B]
-            enc = tok([prompts[i] for i in idx], return_tensors="pt", padding=True,
-                      truncation=True, max_length=gen_cfg.get("max_prompt_len", 96)).to(0)
-            plen = enc["input_ids"].shape[1]
-            gen = model.generate(**enc,
-                                 max_new_tokens=gen_cfg.get("max_new_tokens", 24),
-                                 do_sample=gen_cfg.get("do_sample", False),
-                                 num_beams=gen_cfg.get("num_beams", 1),
-                                 pad_token_id=tok.pad_token_id)
-            new_ids = gen[:, plen:]
-            texts = tok.batch_decode(new_ids, skip_special_tokens=True)
-            for j, i in enumerate(idx):
-                ids = new_ids[j].tolist()
-                n_tok, fin = len(ids), "length"
-                for k, t in enumerate(ids):
-                    if t == tok.eos_token_id:
-                        n_tok, fin = k, "eos"
-                        break
-                out[i] = {"fact_id": facts[i]["fact_id"], "model": args.model,
-                          "prompt": prompts[i],
-                          "raw_response": texts[j],
-                          "generated_token_ids": ids[:n_tok],
-                          "generated_tokens": int(n_tok),
-                          "finish_reason": fin,
-                          "gold_token_len": len(gold_ids[i])}
-
-            if args.save_logprob:
-                full = [prompts[i] + " " + golds[i] for i in idx]
-                enc2 = tok(full, return_tensors="pt", padding=True, truncation=True,
-                           max_length=gen_cfg.get("max_prompt_len", 96) + 32).to(0)
-                lp = torch.log_softmax(model(**enc2).logits.float(), dim=-1)
-                for j, i in enumerate(idx):
-                    g = gold_ids[i]
-                    if not g:
-                        continue
-                    seq = enc2["input_ids"][j]
-                    end = seq.shape[0]
-                    start = end - len(g)
-                    L = int(enc2["attention_mask"][j].sum().item())
-                    if start - 1 < end - L:
-                        continue
-                    vals = [lp[j, t - 1, seq[t]].item() for t in range(start, end)]
-                    row = lp[j, start - 1]
-                    out[i]["gold_sequence_logprob"] = float(sum(vals) / len(vals))
-                    out[i]["gold_first_token_logprob"] = float(row[g[0]].item())
-                    out[i]["gold_first_token_rank"] = int((row > row[g[0]]).sum().item()) + 1
-                    out[i]["first_token_argmax_correct"] = bool(
-                        int(row.argmax().item()) == g[0])
-
-            if b % (B * 20) == 0:
-                done = b + len(idx)
-                print(f"  {done}/{N}  {done / max(time.time() - t0, 1e-9):.1f}/s",
-                      flush=True)
-
-    dest = out_path("qualification", f"{args.model}.jsonl")
-    with open(dest, "w") as f:
-        for r in out:
-            f.write(json.dumps(r, ensure_ascii=False) + "\n")
-    json.dump({"model": args.model, "n": N, "generation": gen_cfg,
-               "model_entry": entry, "seconds": round(time.time() - t0, 1)},
-              open(out_path("qualification", f"{args.model}.meta.json"), "w"),
-              indent=2, ensure_ascii=False)
-    print(f"[{args.model}] wrote {N} -> {dest}  ({time.time() - t0:.0f}s)  GEN_DONE")
-
-
-if __name__ == "__main__":
-    main()

ICLR dataset/runner/qualification_score.py

@@ -1,145 +0,0 @@
-#!/usr/bin/env python
-"""Stage V scoring -> outputs/qualification/<model>.scored.jsonl + K_m labels.
-
-Spec 7.4: CPU-side, modular, five labels. Spec 7.1 / 16: K_m is a label set and
-must never be used to redefine the benchmark denominator, so this script writes
-a per-fact label table covering ALL 2,592 facts for every model rather than a
-filtered subset.
-
-Also emits outputs/known_labels.json:
-    {fact_id: {model: label}}
-which downstream analysis joins against the query bank.
-"""
-import os, sys, json, glob, argparse, collections
-import numpy as np
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from common import load_config, out_path, read_jsonl, write_jsonl
-from scoring_full import score, needs_manual_review
-
-LABELS = ["correct", "incorrect", "ambiguous", "abstain", "unparseable"]
-
-
-def bootstrap_ci(values, groups, n_boot=2000, seed=0, alpha=0.05):
-    """Cluster bootstrap over RELATIONS: the relation mix is heavily skewed
-    (manufacturer + developer + native_language are a third of the benchmark),
-    so treating facts as independent would understate the interval."""
-    rng = np.random.default_rng(seed)
-    by = collections.defaultdict(list)
-    for v, g in zip(values, groups):
-        by[g].append(v)
-    keys = list(by)
-    if not keys:
-        return (float("nan"), float("nan"))
-    arrs = [np.asarray(by[k], dtype=float) for k in keys]
-    stats = np.empty(n_boot)
-    for b in range(n_boot):
-        pick = rng.integers(0, len(keys), len(keys))
-        stats[b] = np.concatenate([arrs[i] for i in pick]).mean()
-    return float(np.quantile(stats, alpha / 2)), float(np.quantile(stats, 1 - alpha / 2))
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--models", nargs="*", default=None)
-    ap.add_argument("--facts", default=out_path("benchmark_facts_2592.jsonl"))
-    args = ap.parse_args()
-
-    facts = {f["fact_id"]: f for f in read_jsonl(args.facts)}
-    qdir = os.path.join(out_path("qualification", "x")[:-1])
-    paths = sorted(p for p in glob.glob(os.path.join(qdir, "*.jsonl"))
-                   if not p.endswith(".scored.jsonl"))
-    if args.models:
-        paths = [p for p in paths
-                 if os.path.basename(p)[:-len(".jsonl")] in args.models]
-    if not paths:
-        raise SystemExit(f"no generation files in {qdir}; run qualification_run.py first")
-
-    known = collections.defaultdict(dict)
-    summary = {}
-    for p in paths:
-        model = os.path.basename(p)[:-len(".jsonl")]
-        rows, counts = [], collections.Counter()
-        by_rel = collections.defaultdict(collections.Counter)
-        by_flag = collections.defaultdict(collections.Counter)
-        for g in read_jsonl(p):
-            f = facts.get(g["fact_id"])
-            if f is None:
-                raise SystemExit(f"{model}: generation for unknown fact {g['fact_id']}")
-            r = score(g["raw_response"], f["object"]["aliases"],
-                      answer_type=f["answer_type"],
-                      granularity=f["answer_granularity"])
-            rec = {"fact_id": g["fact_id"], "model": model,
-                   "prompt": g["prompt"], "raw_response": g["raw_response"],
-                   "extracted_answer": r["span"], "label": r["label"],
-                   "matched_alias": r["matched_alias"], "scorer": r["scorer"],
-                   "flags": r["flags"],
-                   "relation": f["relation"]["relation_id"],
-                   "answer_type": f["answer_type"],
-                   "answer_in_subject_surface": bool(f.get("answer_in_subject_surface")),
-                   "spec_6_2_flag": f.get("spec_6_2_flag"),
-                   "manual_review": needs_manual_review(r)}
-            for k in ("gold_sequence_logprob", "gold_first_token_rank",
-                      "first_token_argmax_correct"):
-                if k in g:
-                    rec[k] = g[k]
-            rows.append(rec)
-            counts[r["label"]] += 1
-            by_rel[f["relation"]["relation_id"]][r["label"]] += 1
-            by_flag[bool(f.get("answer_in_subject_surface"))][r["label"]] += 1
-            known[g["fact_id"]][model] = r["label"]
-
-        write_jsonl(os.path.join(qdir, f"{model}.scored.jsonl"), rows)
-
-        n = len(rows)
-        vals = [1.0 if r["label"] == "correct" else 0.0 for r in rows]
-        rels = [r["relation"] for r in rows]
-        lo, hi = bootstrap_ci(vals, rels)
-        rel_macro = collections.defaultdict(list)
-        for v, rl in zip(vals, rels):
-            rel_macro[rl].append(v)
-        summary[model] = {
-            "n_facts": n,
-            "labels": {k: counts[k] for k in LABELS},
-            "label_rates": {k: round(counts[k] / n, 4) for k in LABELS},
-            "K_m": counts["correct"],
-            "anchor_accuracy_micro": round(counts["correct"] / n, 4),
-            "anchor_accuracy_relation_macro":
-                round(float(np.mean([np.mean(v) for v in rel_macro.values()])), 4),
-            "ci95_relation_clustered": [round(lo, 4), round(hi, 4)],
-            # the copy-shortcut split from reconstruction_differences.md F1
-            "accuracy_answer_in_subject":
-                round(by_flag[True]["correct"] / max(sum(by_flag[True].values()), 1), 4),
-            "accuracy_answer_not_in_subject":
-                round(by_flag[False]["correct"] / max(sum(by_flag[False].values()), 1), 4),
-            "n_manual_review": sum(1 for r in rows if r["manual_review"]),
-            "by_relation": {k: {"n": sum(v.values()), "correct": v["correct"]}
-                            for k, v in sorted(by_rel.items())},
-        }
-
-    # spec 7.1: labels for every fact x model, benchmark denominator untouched
-    json.dump({"n_facts": len(facts), "models": sorted(summary),
-               "note": "K_m is a label set; the benchmark denominator stays 2,592 "
-                       "for every model (spec 2.1 / 7.1)",
-               "labels": known},
-              open(out_path("known_labels.json"), "w"), ensure_ascii=False)
-    json.dump(summary, open(out_path("qualification_summary.json"), "w"),
-              indent=2, ensure_ascii=False)
-
-    print(f"{'model':22s} {'K_m':>6s} {'micro':>7s} {'macro':>7s} "
-          f"{'CI95':>16s} {'abst':>6s} {'ambig':>6s} {'copy':>6s} {'real':>6s}")
-    print("-" * 92)
-    for m, s in summary.items():
-        ci = s["ci95_relation_clustered"]
-        print(f"{m[:21]:22s} {s['K_m']:6d} {s['anchor_accuracy_micro']:7.3f} "
-              f"{s['anchor_accuracy_relation_macro']:7.3f} "
-              f"[{ci[0]:.3f},{ci[1]:.3f}] {s['label_rates']['abstain']:6.3f} "
-              f"{s['label_rates']['ambiguous']:6.3f} "
-              f"{s['accuracy_answer_in_subject']:6.3f} "
-              f"{s['accuracy_answer_not_in_subject']:6.3f}")
-    print("\ncopy = facts whose answer is inside the subject name; "
-          "real = the rest (see reconstruction_differences.md F1)")
-
-
-if __name__ == "__main__":
-    main()

ICLR dataset/runner/scoring_full.py

@@ -1,180 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Answer-span extraction and full-answer scoring (spec section 7.4).
-
-Five labels, unlike the three-way scheme it replaces:
-    correct       an accepted alias is asserted
-    incorrect     a different answer is asserted
-    ambiguous     several incompatible answers, hedging, or a granularity miss
-    abstain       the model declines or says it does not know
-    unparseable   nothing answer-shaped survives extraction
-
-Scoring is a pure function of the stored generation, so rules can be revised
-and everything re-scored without touching the GPU.
-"""
-import re
-import sys
-import os
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from common import normalize
-
-MAX_SPAN_TOKENS = 10
-STRICT_SPAN_TOKENS = 6
-
-# Containment only fires for aliases at least this long. Crowd-sourced Wikidata
-# alias lists include ISO codes that are ordinary English words -- "can" is an
-# alias of Canada, "ja" of Japanese -- and without a floor a generation like
-# "It can be Germany" would contain " can " and score as a correct Canada
-# answer. Short aliases still count, but only through exact match.
-MIN_CONTAINMENT_ALIAS_CHARS = 4
-ALIAS_STOPWORDS = {"can", "may", "will", "was", "are", "one", "two", "new",
-                   "the", "and", "for", "his", "her", "its", "not", "all"}
-
-_LEADIN = re.compile(
-    r"^(?:the\s+answer\s+is|answer\s*:|it\s+is|it\s+was|it's|that\s+would\s+be|"
-    r"that\s+is|this\s+is|he\s+is|she\s+is|they\s+are|he\s+was|she\s+was|"
-    r"they\s+were)\b[\s:,-]*", re.I)
-_NEGATION = re.compile(r"\b(not|no|never|isn't|wasn't|aren't|weren't|doesn't|"
-                       r"didn't|don't|cannot|can't)\b", re.I)
-_HEDGE = re.compile(r"\b(but|however|although|though|actually|maybe|perhaps|"
-                    r"probably|possibly|might|unclear|some\s+sources|depends|"
-                    r"either)\b", re.I)
-_ABSTAIN = re.compile(
-    r"\b(i\s+(?:do\s+not|don't)\s+know|i'm\s+not\s+sure|i\s+am\s+not\s+sure|"
-    r"unknown|not\s+sure|no\s+idea|cannot\s+answer|can't\s+answer|"
-    r"unable\s+to\s+(?:answer|determine)|insufficient\s+information|"
-    r"as\s+an\s+ai)\b", re.I)
-_SENT_END = re.compile(r"[.!?\n]")
-_LIST_SEP = re.compile(r"\s*(?:,|;|\bor\b|\band\b|/|\|)\s*", re.I)
-_YEAR = re.compile(r"\b(1[0-9]{3}|20[0-9]{2})\b")
-
-
-def _tokens(t):
-    return [w for w in re.split(r"[^\w]+", t) if w]
-
-
-def extract_span(raw):
-    """First answer-bearing clause. Returns (span, flags)."""
-    flags = set()
-    if raw is None:
-        return "", {"empty"}
-    text = raw.strip()
-    if not text:
-        return "", {"empty"}
-    lines = [l for l in text.split("\n") if l.strip()]
-    if not lines:
-        return "", {"empty"}
-    if len(lines) > 1:
-        flags.add("multi_clause")
-    first = lines[0].strip()
-    m = _SENT_END.search(first)
-    if m and first[m.start():].strip(" .!?"):
-        flags.add("multi_clause")
-    first = first[:m.start()] if m else first
-
-    if _ABSTAIN.search(first):
-        flags.add("abstain")
-    if _NEGATION.search(first):
-        flags.add("negation")
-    if _HEDGE.search(first):
-        flags.add("hedge")
-
-    span = _LEADIN.sub("", first).strip()
-    if len(_tokens(span)) > MAX_SPAN_TOKENS:
-        flags.add("truncated")
-        span = " ".join(span.split()[:MAX_SPAN_TOKENS])
-    if not span:
-        flags.add("empty")
-    return span, flags
-
-
-def split_candidates(span):
-    parts = [p.strip() for p in _LIST_SEP.split(span) if p.strip()]
-    return parts or ([span] if span else [])
-
-
-def _match_year(span, golds, gran):
-    got = set(_YEAR.findall(span))
-    want = set()
-    for g in golds:
-        want.update(_YEAR.findall(str(g)))
-    if not got or not want:
-        return None
-    if len(got) > 1:
-        return ("ambiguous", None, "year_multiple")
-    y = got.pop()
-    if y not in want:
-        return ("incorrect", None, "year_mismatch")
-    if gran == "date" and not re.search(r"\b\d{1,2}\b", span.replace(y, "")):
-        return ("ambiguous", y, "year_granularity_short")
-    return ("correct", y, "year_parser")
-
-
-def score(raw_generation, gold_aliases, answer_type="entity", granularity=None):
-    """Label one generation. Returns dict(label, matched_alias, scorer, span, flags)."""
-    span, flags = extract_span(raw_generation)
-    out = {"span": span, "flags": sorted(flags)}
-
-    if "abstain" in flags:
-        return {**out, "label": "abstain", "matched_alias": None, "scorer": "abstain"}
-    if "empty" in flags:
-        return {**out, "label": "unparseable", "matched_alias": None, "scorer": "empty_span"}
-    if "negation" in flags:
-        return {**out, "label": "ambiguous", "matched_alias": None, "scorer": "negation"}
-
-    n_span = normalize(span)
-    if not n_span:
-        return {**out, "label": "unparseable", "matched_alias": None,
-                "scorer": "span_normalizes_to_empty"}
-
-    norm_golds = {}
-    for a in gold_aliases:
-        na = normalize(a)
-        if na:
-            norm_golds.setdefault(na, a)
-
-    if n_span in norm_golds:
-        return {**out, "label": "correct", "matched_alias": norm_golds[n_span],
-                "scorer": "exact_alias_after_normalization"}
-
-    if answer_type in ("year", "date"):
-        r = _match_year(span, gold_aliases, granularity or answer_type)
-        if r:
-            lbl, matched, scorer = r
-            return {**out, "label": lbl, "matched_alias": matched, "scorer": scorer}
-
-    cands = split_candidates(span)
-    if len(cands) > 1:
-        hits = [normalize(c) for c in cands if normalize(c) in norm_golds]
-        distinct = set(hits)
-        if len(distinct) == 1 and len(cands) == len(hits):
-            h = distinct.pop()
-            return {**out, "label": "correct", "matched_alias": norm_golds[h],
-                    "scorer": "alias_list_all_accepted"}
-        if hits:
-            return {**out, "label": "ambiguous", "matched_alias": norm_golds[hits[0]],
-                    "scorer": "conflicting_candidates"}
-
-    if "hedge" not in flags and len(_tokens(n_span)) <= STRICT_SPAN_TOKENS:
-        padded = f" {n_span} "
-        for na, orig in norm_golds.items():
-            if len(na) < MIN_CONTAINMENT_ALIAS_CHARS or na in ALIAS_STOPWORDS:
-                continue
-            if f" {na} " in padded:
-                return {**out, "label": "correct", "matched_alias": orig,
-                        "scorer": "alias_substring_short_span"}
-
-    if flags & {"hedge", "truncated", "multi_clause"}:
-        for na, orig in norm_golds.items():
-            if len(na) < MIN_CONTAINMENT_ALIAS_CHARS or na in ALIAS_STOPWORDS:
-                continue
-            if f" {na} " in f" {n_span} ":
-                return {**out, "label": "ambiguous", "matched_alias": orig,
-                        "scorer": "gold_inside_unresolvable_prose"}
-
-    return {**out, "label": "incorrect", "matched_alias": None, "scorer": "no_match"}
-
-
-def needs_manual_review(result):
-    return result["label"] in ("ambiguous", "unparseable") or \
-        result["scorer"] in ("alias_substring_short_span", "year_granularity_short")

ICLR dataset/runner/select_benchmark.py

@@ -1,97 +0,0 @@
-#!/usr/bin/env python
-"""Stage III -> outputs/benchmark_facts_2592.jsonl  (spec section 6)
-
-Two filters, both driven by configs/relations.yaml:
-  6.1  core sources only: CounterFact, LAMA-TREx, PopQA          -> 3,705
-  6.2  functional (single-valued) relations only                 -> 2,592
-
-Spec 6.2 additionally NAMES `developer of` and `manufacturer of` as unsuitable,
-yet the required benchmark size of 2,592 across 21 relations can only be reached
-with them included. That contradiction is inside the specification itself, so
-the default keeps them, tags them with `spec_6_2_flag`, and records the conflict
-in outputs/reconstruction_differences.md. Set
-`options.drop_spec_6_2_flagged: true` in relations.yaml to exclude them; the
-script then reports the resulting size instead of failing.
-"""
-import os, sys, json, argparse, collections
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from common import load_config, out_path, read_jsonl, write_jsonl, Expect
-
-EXPECTED_CORE = 3705
-EXPECTED_BENCHMARK = 2592
-EXPECTED_RELATIONS = 21
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--enriched", default=out_path("enriched_facts_6180.jsonl"))
-    args = ap.parse_args()
-
-    cfg = load_config("relations.yaml")
-    opts = cfg.get("options", {})
-    drop_flagged = bool(opts.get("drop_spec_6_2_flagged", False))
-    exp = Expect()
-
-    facts = list(read_jsonl(args.enriched))
-    exp.check("enriched_input", len(facts), 6180)
-
-    core = [f for f in facts if f["is_core_source"]]
-    exp.check("core_source_facts", len(core), EXPECTED_CORE)
-
-    bench, dropped = [], collections.Counter()
-    for f in core:
-        if not f["is_benchmark_relation"]:
-            dropped["not_a_benchmark_relation"] += 1
-            continue
-        if not f["is_functional"]:
-            dropped["non_functional_relation"] += 1
-            continue
-        if drop_flagged and f.get("spec_6_2_flag"):
-            dropped["spec_6_2_flagged"] += 1
-            continue
-        bench.append(f)
-
-    rel_counts = collections.Counter(f["relation"]["relation_id"] for f in bench)
-    exp.check("benchmark_facts", len(bench),
-              None if drop_flagged else EXPECTED_BENCHMARK,
-              note="drop_spec_6_2_flagged=true" if drop_flagged else "")
-    exp.check("benchmark_relations", len(rel_counts),
-              None if drop_flagged else EXPECTED_RELATIONS)
-
-    flagged = sum(1 for f in bench if f.get("spec_6_2_flag"))
-
-    path = out_path("benchmark_facts_2592.jsonl")
-    write_jsonl(path, bench)
-
-    exp.report("Stage III counts")
-    meta = {
-        "stage": "III_benchmark_selection",
-        "n_enriched": len(facts),
-        "n_core_source": len(core),
-        "n_benchmark": len(bench),
-        "n_relations": len(rel_counts),
-        "per_relation": dict(rel_counts.most_common()),
-        "per_source": dict(collections.Counter(f["sources"][0] for f in bench)),
-        "per_answer_type": dict(collections.Counter(f["answer_type"] for f in bench)),
-        "dropped": dict(dropped),
-        "spec_6_2_flagged_kept": flagged,
-        "drop_spec_6_2_flagged": drop_flagged,
-        "inverse_well_posed_facts": sum(1 for f in bench if f["is_inverse_well_posed"]),
-        "checks": exp.rows,
-    }
-    json.dump(meta, open(out_path("stage3_report.json"), "w"),
-              indent=2, ensure_ascii=False)
-
-    print(f"\nwrote {len(bench)} benchmark facts -> {path}")
-    print(f"  relations: {len(rel_counts)}")
-    print(f"  dropped:   {dict(dropped)}")
-    if flagged:
-        print(f"  NOTE: {flagged} facts come from relations spec 6.2 calls "
-              f"unsuitable (manufacturer/developer); required to reach 2,592. "
-              f"See outputs/reconstruction_differences.md")
-    return 1 if exp.deviations else 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

ICLR dataset/runner/test_scoring.py

@@ -1,70 +0,0 @@
-#!/usr/bin/env python
-"""Unit tests for scoring_full.py. Run before trusting any K_m."""
-import os, sys
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from scoring_full import score
-
-CANBERRA = ["Canberra", "Canberra, ACT"]
-DUTCH = ["Dutch", "Nederlands", "dutch language"]
-YEAR = ["1987"]
-# "can" is a real Wikidata alias of Canada, carried by 67 facts in this pool
-CANADA = ["Canada", "can", "CAN", "Dominion of Canada"]
-
-CASES = [
-    (" Canberra",               CANBERRA, "city", None, "correct", "bare answer"),
-    (" Canberra.",              CANBERRA, "city", None, "correct", "trailing period"),
-    ("The answer is Canberra.", CANBERRA, "city", None, "correct", "lead-in"),
-    ("  canberra  ",            CANBERRA, "city", None, "correct", "case/space"),
-    ("Canberra, ACT",           CANBERRA, "city", None, "correct", "alias with comma"),
-    ("Sydney",                  CANBERRA, "city", None, "incorrect", "wrong entity"),
-    ("It is not Canberra.",     CANBERRA, "city", None, "ambiguous", "negation"),
-    ("Canberra or Sydney",      CANBERRA, "city", None, "ambiguous", "conflicting list"),
-    ("Some sources say Canberra, but the answer is Melbourne.",
-                                CANBERRA, "city", None, "ambiguous", "self-correction"),
-    ("",                        CANBERRA, "city", None, "unparseable", "empty"),
-    ("\n\n",                    CANBERRA, "city", None, "unparseable", "whitespace only"),
-    ("...",                     CANBERRA, "city", None, "unparseable", "punctuation only"),
-
-    ("I don't know.",           CANBERRA, "city", None, "abstain", "explicit refusal"),
-    ("I'm not sure, maybe Sydney.", CANBERRA, "city", None, "abstain", "hedged refusal"),
-    ("Unknown",                 CANBERRA, "city", None, "abstain", "unknown"),
-
-    (" Dutch",                  DUTCH, "language", None, "correct", "primary alias"),
-    (" Nederlands",             DUTCH, "language", None, "correct", "non-primary alias"),
-    ("The Dutch language",      DUTCH, "language", None, "correct", "article + alias"),
-    ("German",                  DUTCH, "language", None, "incorrect", "wrong language"),
-    ("Amsterdam, which is in the Netherlands, where people speak Dutch and",
-                                DUTCH, "language", None, "ambiguous",
-                                "gold buried in prose is NOT a silent correct"),
-
-    ("1987",                    YEAR, "year", "year", "correct", "exact year"),
-    ("He was born in 1987",     YEAR, "year", "year", "correct", "year in short prose"),
-    ("12 March 1987",           YEAR, "year", "year", "correct", "full date, year gold"),
-    ("1988",                    YEAR, "year", "year", "incorrect", "wrong year"),
-    ("1987 or 1988",            YEAR, "year", "year", "ambiguous", "two years"),
-    ("1987",       ["12 March 1987"], "date", "date", "ambiguous", "gold wants full date"),
-    ("12 March 1987", ["12 March 1987"], "date", "date", "correct", "full date matches"),
-
-    ("It can be Germany",       CANADA, "country", None, "incorrect",
-     "stopword alias must not match by containment"),
-    ("Canada",                  CANADA, "country", None, "correct", "primary alias"),
-    ("CAN",                     CANADA, "country", None, "correct", "short alias, EXACT only"),
-    ("the Dominion of Canada is", CANADA, "country", None, "correct",
-     "long alias still matches by containment"),
-]
-
-
-def main():
-    bad = 0
-    for gen, al, at, gran, want, note in CASES:
-        got = score(gen, al, answer_type=at, granularity=gran)
-        ok = got["label"] == want
-        bad += 0 if ok else 1
-        print(f"{'ok ' if ok else 'FAIL'} {want:12s} got={got['label']:12s} "
-              f"{got['scorer']:34s} {note}")
-    print(f"\n{len(CASES) - bad}/{len(CASES)} passed")
-    return 1 if bad else 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

ICLR dataset/runner/validate_facts.py

@@ -1,208 +0,0 @@
-#!/usr/bin/env python
-"""Fact- and query-level validation -> outputs/validation_report.json
-
-Spec 6.3 lists the fact-level gates, spec 13 the query-level ones, spec 14.2 the
-report shape. Exits non-zero on any hard error so a broken build can never reach
-a GPU run.
-"""
-import os, re, sys, json, glob, argparse, collections
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from common import load_config, out_path, read_jsonl, normalize
-
-EVAL_LEGACY = "/scratch/rds-fei-rsfm-rw/cshi0459/ICLR27/eval_dataset"
-
-
-def load_perturbation_prompts():
-    """Normalized text of every evaluation perturbation prompt, for the spec 16
-    check that a qualification template is never reused as an eval template."""
-    out = set()
-    for p in glob.glob(f"{EVAL_LEGACY}/query*.jsonl"):
-        for d in read_jsonl(p):
-            out.add(normalize(d.get("prompt", "")))
-    return out
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--facts", default=out_path("benchmark_facts_2592.jsonl"))
-    ap.add_argument("--queries", default=out_path("evaluation_queries_44418.jsonl"))
-    ap.add_argument("--skip_leakage", action="store_true")
-    args = ap.parse_args()
-
-    cond_cfg = load_config("eval_conditions.yaml")
-    errors = collections.Counter()
-    warnings = collections.Counter()
-    examples = collections.defaultdict(list)
-
-    def err(tag, ref, detail=""):
-        errors[tag] += 1
-        if len(examples[tag]) < 5:
-            examples[tag].append(f"{ref} {detail}".strip())
-
-    def warn(tag, ref, detail=""):
-        warnings[tag] += 1
-        if len(examples[tag]) < 5:
-            examples[tag].append(f"{ref} {detail}".strip())
-
-    # =================================================== fact level (spec 6.3)
-    facts = list(read_jsonl(args.facts))
-    seen_ids, seen_norm = set(), collections.Counter()
-    for f in facts:
-        fid = f.get("fact_id")
-        s, r, o = f.get("subject", {}), f.get("relation", {}), f.get("object", {})
-        if not fid:
-            err("missing_fact_id", "?")
-        elif fid in seen_ids:
-            err("duplicate_fact_id", fid)
-        seen_ids.add(fid)
-
-        if not (s.get("canonical") or "").strip():
-            err("empty_subject", fid)
-        if not (r.get("relation_id") or "").strip():
-            err("empty_relation", fid)
-        if not (o.get("canonical") or "").strip():
-            err("empty_object", fid)
-
-        q = f.get("qualification_question") or ""
-        if not q.strip():
-            err("empty_qualification_question", fid)
-        elif normalize(s.get("canonical", "")) and \
-                normalize(s["canonical"]) not in normalize(q):
-            warn("subject_not_in_question", fid, q)
-
-        al = o.get("aliases") or []
-        if not al:
-            err("no_object_alias", fid)
-        elif normalize(o["canonical"]) not in {normalize(a) for a in al}:
-            err("canonical_object_not_in_aliases", fid, o.get("canonical", ""))
-
-        if not f.get("answer_type"):
-            err("missing_answer_type", fid)
-        if not f.get("answer_granularity"):
-            err("missing_answer_granularity", fid)
-        if not f.get("sources"):
-            err("missing_source_metadata", fid)
-        if not f.get("is_functional"):
-            err("main_relation_not_functional", fid, r.get("relation_id", ""))
-        if len(o.get("variant_surface_forms") or []) > 1 and f["is_functional"]:
-            # survived 5.2 only if all variants share one entity id
-            if not o.get("entity_id"):
-                err("unresolved_functional_conflict", fid)
-        if not (s.get("aliases") or []):
-            warn("no_subject_alias", fid)
-        seen_norm[(normalize(s.get("canonical", "")),
-                   r.get("relation_id"),
-                   normalize(o.get("canonical", "")))] += 1
-
-    dup_norm = {k: v for k, v in seen_norm.items() if v > 1}
-    if dup_norm:
-        errors["duplicate_normalized_fact"] = len(dup_norm)
-        examples["duplicate_normalized_fact"] = [str(k) for k in list(dup_norm)[:5]]
-
-    # spec 16: qualification template must not be an evaluation template
-    if not args.skip_leakage and os.path.isdir(EVAL_LEGACY):
-        pert = load_perturbation_prompts()
-        for f in facts:
-            if normalize(f["qualification_question"]) in pert:
-                err("qualification_question_reused_as_eval_template",
-                    f["fact_id"], f["qualification_question"])
-
-    # ================================================== query level (spec 13)
-    facts_by_id = {f["fact_id"]: f for f in facts}
-    queries = []
-    if os.path.exists(args.queries):
-        queries = list(read_jsonl(args.queries))
-        fact_ids = seen_ids
-        seen_q = set()
-        main_families = {c for c, v in cond_cfg["conditions"].items()
-                         if v["use_for_main_forward"]}
-        for q in queries:
-            qid = q.get("query_id")
-            if not qid:
-                err("missing_query_id", "?")
-            elif qid in seen_q:
-                err("duplicate_query_id", qid)
-            seen_q.add(qid)
-
-            if q.get("fact_id") not in fact_ids:
-                err("query_references_unknown_fact", qid, str(q.get("fact_id")))
-            if not (q.get("gold_aliases") or []):
-                err("missing_gold_aliases", qid)
-            if not q.get("query", "").strip():
-                err("empty_query_text", qid)
-
-            fam = q.get("condition_family")
-            spec_c = cond_cfg["conditions"].get(fam)
-            if spec_c is None:
-                err("unknown_condition_family", qid, str(fam))
-                continue
-            # booleans must agree with the registry, otherwise an aggregation
-            # that trusts the row would silently mix families
-            for flag in ("use_for_main_forward", "use_for_reverse_analysis",
-                         "use_for_recognition_analysis", "is_assisted"):
-                if bool(q.get(flag)) != bool(spec_c[flag]):
-                    err(f"flag_mismatch_{flag}", qid, fam)
-            if q.get("target_slot") != spec_c["target_slot"]:
-                err("target_slot_mismatch", qid, fam)
-
-            # spec 2.3 / 16 hard prohibitions
-            if fam == "recognition" and q.get("use_for_main_forward"):
-                err("recognition_in_main_forward", qid)
-            if fam == "reverse_illposed" and q.get("use_for_main_forward"):
-                err("reverse_illposed_in_main_forward", qid)
-            if fam in main_families and q.get("target_slot") != "object":
-                err("invalid_main_target_slot", qid, str(q.get("target_slot")))
-            # spec 13.9: an open-ended main query must not expose the answer.
-            # A gold string that is part of the SUBJECT name ("Airbus A318" ->
-            # "Airbus") is inherent to the fact, not leakage introduced by the
-            # template, so it is a warning carrying the count rather than a hard
-            # error. Only an occurrence that survives removing every subject
-            # mention is a genuine template leak.
-            if fam in main_families and not q.get("is_assisted"):
-                nq = normalize(q["query"])
-                gold = normalize(q.get("gold_canonical", ""))
-                if gold and gold in nq:
-                    subj = normalize(
-                        facts_by_id[q["fact_id"]]["subject"]["canonical"]
-                    ) if q["fact_id"] in facts_by_id else ""
-                    residual = nq.replace(subj, " ") if subj else nq
-                    if gold in residual:
-                        err("gold_exposed_by_template", qid, q["query"][:70])
-                    else:
-                        warn("gold_inside_subject_name", qid, q["query"][:70])
-
-    # ============================================================== report
-    report = {
-        "hard_errors": int(sum(errors.values())),
-        "warnings": [{"type": k, "count": v, "examples": examples[k][:3]}
-                     for k, v in warnings.most_common()],
-        "errors": [{"type": k, "count": v, "examples": examples[k][:3]}
-                   for k, v in errors.most_common()],
-        "fact_count": len(facts),
-        "query_count": len(queries),
-        "relation_count": len({f["relation"]["relation_id"] for f in facts}),
-        "duplicate_fact_ids": int(errors.get("duplicate_fact_id", 0)),
-        "duplicate_query_ids": int(errors.get("duplicate_query_id", 0)),
-        "missing_gold_aliases": int(errors.get("missing_gold_aliases", 0)),
-        "invalid_main_target_slots": int(errors.get("invalid_main_target_slot", 0)),
-        "recognition_in_main_forward": int(errors.get("recognition_in_main_forward", 0)),
-        "reverse_illposed_in_main_forward":
-            int(errors.get("reverse_illposed_in_main_forward", 0)),
-    }
-    json.dump(report, open(out_path("validation_report.json"), "w"),
-              indent=2, ensure_ascii=False)
-
-    print(f"facts={len(facts)}  queries={len(queries)}  "
-          f"relations={report['relation_count']}")
-    print(f"\nHARD ERRORS: {report['hard_errors']}")
-    for k, v in errors.most_common():
-        print(f"  {k:46s} {v:6d}  e.g. {examples[k][:1]}")
-    print(f"\nWARNINGS: {sum(warnings.values())}")
-    for k, v in warnings.most_common():
-        print(f"  {k:46s} {v:6d}  e.g. {examples[k][:1]}")
-    return 1 if report["hard_errors"] else 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())