Image-level person classification on EUPE-ViT-B features with a single free parameter

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.py[cod]
+.pytest_cache/
+*.egg-info/
+
+# Synthesis build products; regenerate with `make synth`.
+build/

Makefile

@@ -0,0 +1,20 @@
+# make test    run the backbone-free consistency suite
+# make rtl     regenerate rtl/ from per_dim_thresholds.json
+# make synth   synthesize every decision variant with nosis
+# make clean
+
+PYTHON ?= python
+
+test:
+	$(PYTHON) -m pytest -q
+
+rtl:
+	$(PYTHON) rtl_gen.py
+
+synth: rtl
+	$(PYTHON) synth.py
+
+clean:
+	rm -rf build
+
+.PHONY: test rtl synth clean

README.md

@@ -0,0 +1,184 @@
+---
+license: other
+license_name: fair-research-license
+license_link: https://huggingface.co/facebook/EUPE-ViT-B/blob/main/LICENSE
+base_model: facebook/EUPE-ViT-B
+tags:
+  - image-classification
+  - binary-classification
+  - minimal-models
+  - interpretability
+  - vision-transformer
+  - circuit-synthesis
+library_name: pytorch
+datasets:
+  - detection-datasets/coco
+pipeline_tag: image-classification
+---
+
+# 1-Parameter Classifier
+
+Image-level person classification on EUPE-ViT-B features. A 768 pixel image
+gives 2304 patch tokens at the final layer; layernorm across the 768 channels
+and max-pool across patches gives one 768-D vector. The classifier reads 40 of
+its dimensions, 20 person-positive and 20 person-negative, sums the positives,
+subtracts the negatives, and compares the result to one threshold. The dimension
+indices and their signs are fixed structure; the threshold, 25.284, is the only
+value fitted to data.
+
+```python
+patches = backbone(image)["x_norm_patchtokens"]      # (2304, 768)
+pooled  = layernorm(patches, 768).max(dim=0)         # (768,)
+score   = pooled[pos_dims].sum() - pooled[neg_dims].sum()
+present = score > threshold                          # the only free parameter
+```
+
+```python
+from infer import PersonDetector
+det = PersonDetector.load('baseline')
+score, present = det.predict('image.jpg')
+```
+
+## Variants
+
+| variant | dims | F1 | precision | recall | prop-FPR |
+|---|---:|---:|---:|---:|---:|
+| `baseline` | 40 | 0.8886 | 0.9011 | 0.8763 | 5.93 % |
+| `tight_fpr` | 55 | 0.8527 | 0.8967 | 0.8127 | 2.72 % |
+
+`baseline` is measured on all 5000 images of COCO val2017 through a backbone
+forward at 768 px. `tight_fpr` keeps the same 20 positive dimensions and extends
+the negative set with 15 mined from person-associated objects photographed
+without people; it trades 0.036 F1 for a prop false-positive rate of 2.72 %. Its
+row is measured by `discovery/prop_specificity.json` at `extra_neg_k` 15, which
+recorded no pool, and is not comparable with the `VAL5000` figure.
+
+## Dimension selection
+
+`discovery/dim_selection.json`: 100,000 random 92-dimension subsets of the 768-D
+space, a ridge classifier per subset, the top 1 % kept, dimension occurrence
+counted across that cohort. Dimension 48 appears in 100 % of the top 1000
+subsets; the next strongest, 525, appears in 31 %.
+
+`discovery/dim48_characterization.json`: five analyses on dimension 48. F1
+against K. Activation distributions for person-positive and person-negative
+images, Cohen's d 1.98. Per-class activation delta across all 80 COCO
+categories. Pairwise correlation among the ten most frequent dimensions, maximum
+absolute value 0.57. Spatial IoU of peak activations against ground-truth person
+boxes, mean 0.17.
+
+`discovery/variant_leaderboard.json`: 20 classifier forms from 1 to 769
+parameters. Ternary ±1 over 50 positive and 50 negative dimensions leads at F1
+0.893.
+
+Dimension 48 responds to people and to person-associated objects and is
+suppressed on non-human animals and on non-anthropogenic structures. Alone it
+reaches F1 0.83 as a 2-parameter classifier. The other 39 dimensions carry
+largely orthogonal axes and reach 0.89 at one free parameter.
+
+## Prop specificity
+
+`discovery/prop_specificity.json` and `prop_image_manifest.json` measure
+separation between "person present" and "person-associated object present, no
+person". 8,479 ImageNet training images across 20 such synsets were filtered
+with YOLO26l at confidence 0.25 to keep only frames with no detected person.
+`baseline` fires on 5.9 % of them. Adding prop-specific negative dimensions
+takes that to 2.7 % at K=15, which is the knee and what
+`classifier_tight_fpr.json` carries.
+
+## Circuit
+
+Inputs are the 40 selected channels as signed INT8, post-layernorm,
+post-max-pool and indexed. Output is one bit, combinational, with no multipliers
+and no memory. Two forms, each synthesized with thresholds as runtime inputs and
+with them baked in.
+
+| variant | thresholds | slices | LUT4 | CCU2C | bound | ns |
+|---|---|---:|---:|---:|---|---:|
+| `sum` | runtime | 312 | 31 | 312 | carry | 10.40 |
+| `sum_folded` | baked | 312 | 21 | 312 | carry | 10.40 |
+| `popcount` | runtime | 146 | 291 | 118 | lut | 10.80 |
+| `popcount_folded` | baked | 118 | 109 | 118 | carry | 10.80 |
+
+```
+additive   score = sum(pos) - sum(neg)          40 x 8-bit adder tree
+           out   = score > T                    16-bit signed comparator
+
+popcount   b_i   = f_i > t_i                    40 x 8-bit comparators
+           out   = popcount(b_0..b_19)
+                 - popcount(b_20..b_39) > K     two 20->5 bit counts, small compare
+```
+
+The popcount form replaces the signed adder tree with 40 independent one-bit
+decisions, taking the carry chain from 312 cells to 118. Each channel retains
+only which side of its threshold it fell on.
+
+```
+form                          F1
+additive, float               0.884
+popcount, K=13                0.876    -0.008
+```
+
+Measured on `BALANCED_VAL`, where the additive figure is 0.884 against the 0.889
+measured on `VAL5000`. Both come from the same measurement.
+
+Synthesis is [nosis](https://github.com/CharlesCNorton/nosis) targeting a
+Lattice ECP5 LFE5U-25F. Counts are LUT4s, carry cells and slices on that device.
+`calibrate.py` selects the 40 per-dimension thresholds and the integer K and
+writes `per_dim_thresholds.json`; `rtl_gen.py` emits all four modules from that
+file. INT8 constants are the calibrated float values scaled by 8.
+
+## Layout
+
+```
+common/                     pooled features, ternary scoring, metrics, named pools
+classifier.json, .safetensors                dimensions, signs and the threshold
+classifier_tight_fpr.json, .safetensors      the low-false-fire variant
+head.py                     the decision as a fused Linear with ternary weights
+verify.py                   scores a config over a named pool, writes eval.json
+calibrate.py                per-dimension calibration, writes per_dim_thresholds.json
+rtl_gen.py                  Verilog generation from per_dim_thresholds.json
+synth.py                    nosis synthesis, writes circuit.json
+infer.py                    loader for both variants
+discovery/                  how the 40 dimensions were chosen
+rtl/                        the four decision modules, all generated
+tests/                      consistency suite, no backbone or dataset required
+```
+
+Each measured JSON opens with a provenance block naming its generating script,
+the classifier config it read and that config's hash, and the pool.
+`tests/test_artifacts.py` enforces the pairing. The five files under
+`discovery/` record a null generator; their sweeps are not committed.
+
+## Running
+
+```
+pip install -e .
+make test                       # consistency suite
+python verify.py                # baseline on VAL5000
+python calibrate.py             # thresholds, then all four modules
+make synth                      # synthesize with nosis
+```
+
+`COCO_ROOT` is the dataset root. `BACKBONE` is the backbone repo id or a local
+path. `BACKBONE_SRC` supplies `argus.py` from a local directory; otherwise it is
+fetched from the backbone repo.
+
+## Evaluation pools
+
+Declared in `common/pools.py` and named in each artifact's provenance block.
+Figures are comparable only within a pool.
+
+| pool | images |
+|---|---|
+| `VAL5000` | all 5000 of COCO val2017 |
+| `CALIB1000` | first 1000 val2017 ids |
+| `VAL500` | first 500 val2017 ids |
+| `BALANCED_VAL` | val2017 subsampled to equal classes |
+
+## Source backbone
+
+EUPE-ViT-B from Meta FAIR ([arXiv:2603.22387](https://arxiv.org/abs/2603.22387),
+Zhu et al., March 2026), distilled from PEcore-G + PElang-G + DINOv3-H+ via a
+1.9B proxy teacher. License: FAIR Research License, non-commercial. This
+classifier is an artifact derived from that backbone's feature geometry.

calibrate.py

@@ -0,0 +1,107 @@
+"""Calibrate the popcount reformulation and regenerate the RTL.
+
+Per-dim thresholds are chosen on a balanced COCO val subsample: for a
+person-positive dim the split maximizing F1 under `value > t`, for a
+person-negative dim under `value < t`. Either way the split point is the same
+cut, and at inference every channel uses `>` because the negative count is
+subtracted.
+
+Writes per_dim_thresholds.json, then calls rtl_gen so the baked constants cannot
+drift from the calibration that produced them.
+"""
+import argparse
+import json
+import sys
+from pathlib import Path
+
+import torch
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))  # repo root, for `common`
+from common import (COCO_ROOT, D, balanced_indices, coco_split, device,  # noqa: E402
+                    f1_sweep, person_labels, pool, prf1, write_artifact)
+from common.pools import BALANCED_VAL  # noqa: E402
+
+import rtl_gen  # noqa: E402
+
+HERE = Path(__file__).resolve().parent
+CLASSIFIER = HERE / 'classifier.json'
+QUANT_SCALE = 8  # INT8 fixed-point scale for the layernormed feature values
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument('--cache', type=Path,
+                    default=COCO_ROOT / 'val_feature_cache_768' / 'val.pt')
+    ap.add_argument('--seed', type=int, default=0)
+    args = ap.parse_args()
+
+    dev = device()
+    c = json.loads(CLASSIFIER.read_text())
+    pos_dims, neg_dims = c['pos_dims'], c['neg_dims']
+    all_dims = pos_dims + neg_dims
+    n_pos = len(pos_dims)
+
+    print('[load] val features and person labels', flush=True)
+    val = torch.load(args.cache, map_location='cpu', weights_only=False)
+    coco, _ = coco_split('val2017')
+    ids = [int(e['img_id']) for e in val]
+    feats = torch.stack([pool(e['spatial'].float().permute(1, 2, 0).reshape(-1, D))
+                         for e in val]).to(dev)[:, all_dims]
+    y = person_labels(coco, ids, dev)
+    print(f'  N={feats.shape[0]}  person_rate={y.float().mean():.3f}', flush=True)
+
+    sel = balanced_indices(y, args.seed)
+    X, yb = feats[sel.to(dev)], y[sel.to(dev)]
+    print(f'[balanced] N={len(sel)}  person_rate={yb.float().mean():.3f}', flush=True)
+
+    per_dim = []
+    for local, global_dim in enumerate(all_dims):
+        vals = X[:, local]
+        is_pos = local < n_pos
+        candidates = torch.quantile(vals, torch.linspace(0.05, 0.95, 19, device=dev))
+        best = (0.0, 0.0)
+        for t in candidates.tolist():
+            m = prf1(vals > t if is_pos else vals < t, yb)
+            if m.f1 > best[0]:
+                best = (m.f1, t)
+        per_dim.append({'dim_index_in_40': local, 'dim_global': int(global_dim),
+                        'is_pos': is_pos, 'threshold': best[1],
+                        'threshold_int8': int(round(best[1] * QUANT_SCALE)),
+                        'per_dim_F1': best[0]})
+    lo = min(p['per_dim_F1'] for p in per_dim)
+    hi = max(p['per_dim_F1'] for p in per_dim)
+    print(f'[per-dim] calibrated, standalone F1 range {lo:.3f} - {hi:.3f}', flush=True)
+
+    bits = torch.stack([X[:, p['dim_index_in_40']] > p['threshold'] for p in per_dim], 1)
+    diff = (bits[:, :n_pos].sum(1) - bits[:, n_pos:].sum(1)).float()
+    best_k, best_m = 0, prf1(diff > 0, yb)
+    for t in range(-20, 21):
+        m = prf1(diff > t, yb)
+        if m.f1 > best_m.f1:
+            best_k, best_m = t, m
+    print(f'[popcount] F1={best_m.f1:.4f}  P={best_m.precision:.4f}  '
+          f'R={best_m.recall:.4f}  K={best_k}', flush=True)
+
+    sums = X[:, :n_pos].sum(1) - X[:, n_pos:].sum(1)
+    add = f1_sweep(sums, yb)
+    print(f'[additive] F1={add.f1:.4f}  P={add.precision:.4f}  R={add.recall:.4f}  '
+          f't={add.threshold:.3f}', flush=True)
+
+    write_artifact(HERE / 'per_dim_thresholds.json', {
+        'quant_scale': QUANT_SCALE,
+        'per_dim_thresholds': per_dim,
+        'popcount': {'final_threshold': int(best_k), **best_m.asdict()},
+        'additive': add.asdict(),
+        'F1_delta_popcount_vs_additive': best_m.f1 - add.f1,
+    }, generator='calibrate.py', classifier=CLASSIFIER,
+        pool=BALANCED_VAL.name, split=BALANCED_VAL.split, n_images=int(len(sel)),
+        positive_rate=round(yb.float().mean().item(), 4),
+        selection=BALANCED_VAL.selection, seed=args.seed)
+
+    for path in rtl_gen.generate():
+        print(f'[rtl] wrote {path}', flush=True)
+    print('[done]', flush=True)
+
+
+if __name__ == '__main__':
+    main()

circuit.json

@@ -0,0 +1,64 @@
+{
+  "provenance": {
+    "generator": "synth.py",
+    "tool": "nosis",
+    "target": {
+      "family": "ecp5",
+      "device": "LFE5U-25F"
+    },
+    "inputs": "40 signed INT8 feature channels at the classifier dims",
+    "note": "LUT4, carry and slice counts on an ECP5, not abstract gates"
+  },
+  "variants": {
+    "sum": {
+      "slices": 312,
+      "lut4": 31,
+      "ccu2c": 312,
+      "ffs": 0,
+      "bound": "carry",
+      "critical_path_ns": 10.4,
+      "device": "LFE5U-25F",
+      "rtl": "rtl/sum.v",
+      "thresholds": "runtime input"
+    },
+    "sum_folded": {
+      "slices": 312,
+      "lut4": 21,
+      "ccu2c": 312,
+      "ffs": 0,
+      "bound": "carry",
+      "critical_path_ns": 10.4,
+      "device": "LFE5U-25F",
+      "rtl": "rtl/sum_folded.v",
+      "thresholds": "baked"
+    },
+    "popcount": {
+      "slices": 146,
+      "lut4": 291,
+      "ccu2c": 118,
+      "ffs": 0,
+      "bound": "lut",
+      "critical_path_ns": 10.8,
+      "device": "LFE5U-25F",
+      "rtl": "rtl/popcount.v",
+      "thresholds": "runtime inputs"
+    },
+    "popcount_folded": {
+      "slices": 118,
+      "lut4": 109,
+      "ccu2c": 118,
+      "ffs": 0,
+      "bound": "carry",
+      "critical_path_ns": 10.8,
+      "device": "LFE5U-25F",
+      "rtl": "rtl/popcount_folded.v",
+      "thresholds": "baked"
+    }
+  },
+  "accuracy": {
+    "protocol": "balanced COCO val subsample, see calibrate.py",
+    "additive_F1": 0.8843,
+    "popcount_F1": 0.8764,
+    "delta": -0.0079
+  }
+}

classifier.json

@@ -0,0 +1,19 @@
+{
+  "backbone": "facebook/EUPE-ViT-B",
+  "feature_dim": 768,
+  "input_resolution": 768,
+  "patch_size": 16,
+  "patch_grid": [48, 48],
+  "preprocessing": "layernorm over 768 channels then max-pool over 2304 patches",
+  "pos_dims": [48, 525, 475, 645, 273, 292, 158, 510, 506, 337, 8, 309, 267, 217, 79, 13, 657, 207, 722, 311],
+  "neg_dims": [642, 224, 113, 565, 49, 637, 45, 520, 219, 290, 529, 617, 269, 745, 576, 701, 105, 694, 82, 283],
+  "pos_weight": 1.0,
+  "neg_weight": -1.0,
+  "threshold": 25.284494400024414,
+  "decision": "sum(feat[pos_dims]) - sum(feat[neg_dims]) > threshold",
+  "free_parameters": 1,
+  "fixed_parameters": {
+    "dim_indices": 40,
+    "signs": 40
+  }
+}

classifier.safetensors

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

classifier_tight_fpr.json

@@ -0,0 +1,121 @@
+{
+  "variant": "stage_0_tight_fpr",
+  "parent": "classifier.json",
+  "description": "Extended-negative-dims classifier tuned for low prop-FPR. Positive dims unchanged; negative dims extended with 15 prop-correlated dims discovered via YOLO-filtered ImageNet prop-only images. See discovery/prop_specificity.json.",
+  "backbone": "facebook/EUPE-ViT-B",
+  "feature_dim": 768,
+  "input_resolution": 768,
+  "patch_size": 16,
+  "patch_grid": [
+    48,
+    48
+  ],
+  "preprocessing": "layernorm over 768 channels then max-pool over 2304 patches",
+  "pos_dims": [
+    48,
+    525,
+    475,
+    645,
+    273,
+    292,
+    158,
+    510,
+    506,
+    337,
+    8,
+    309,
+    267,
+    217,
+    79,
+    13,
+    657,
+    207,
+    722,
+    311
+  ],
+  "neg_dims_original": [
+    642,
+    224,
+    113,
+    565,
+    49,
+    637,
+    45,
+    520,
+    219,
+    290,
+    529,
+    617,
+    269,
+    745,
+    576,
+    701,
+    105,
+    694,
+    82,
+    283
+  ],
+  "neg_dims_extra": [
+    11,
+    697,
+    572,
+    671,
+    51,
+    186,
+    752,
+    90,
+    161,
+    310,
+    88,
+    189,
+    613,
+    201,
+    360
+  ],
+  "neg_dims": [
+    642,
+    224,
+    113,
+    565,
+    49,
+    637,
+    45,
+    520,
+    219,
+    290,
+    529,
+    617,
+    269,
+    745,
+    576,
+    701,
+    105,
+    694,
+    82,
+    283,
+    11,
+    697,
+    572,
+    671,
+    51,
+    186,
+    752,
+    90,
+    161,
+    310,
+    88,
+    189,
+    613,
+    201,
+    360
+  ],
+  "pos_weight": 1.0,
+  "neg_weight": -1.0,
+  "threshold": 10.094175338745117,
+  "decision": "sum(feat[pos_dims]) - sum(feat[neg_dims]) > threshold",
+  "free_parameters": 1,
+  "fixed_parameters": {
+    "dim_indices": 55,
+    "signs": 55
+  }
+}

classifier_tight_fpr.safetensors

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

common/__init__.py

@@ -0,0 +1,22 @@
+"""Pooled features, ternary scoring, metrics, named pools, artifact contract."""
+from .paths import BACKBONE, BACKBONE_SRC, COCO_ROOT, REPO, UPSTREAM_BACKBONE, device
+from .data import (MEAN, STD, coco_split, image_paths, load_image, normalize,
+                   person_labels)
+from .features import D, RES, backbone_pooled, pool, score, score_pool
+from .metrics import Metrics, f1_at, f1_sweep, prf1
+from .pools import BALANCED_VAL, CALIB1000, POOLS, VAL500, VAL5000, Pool, by_name
+from .pool import LoadedPool, balanced_indices, load_pool
+from .artifacts import (REGISTRY, ArtifactSpec, provenance, read_artifact,
+                        sha256_of, write_artifact)
+
+__all__ = [
+    'BACKBONE', 'BACKBONE_SRC', 'COCO_ROOT', 'REPO', 'UPSTREAM_BACKBONE', 'device',
+    'MEAN', 'STD', 'coco_split', 'image_paths', 'load_image', 'normalize',
+    'person_labels',
+    'D', 'RES', 'backbone_pooled', 'pool', 'score', 'score_pool',
+    'Metrics', 'f1_at', 'f1_sweep', 'prf1',
+    'BALANCED_VAL', 'CALIB1000', 'POOLS', 'VAL500', 'VAL5000', 'Pool', 'by_name',
+    'LoadedPool', 'balanced_indices', 'load_pool',
+    'REGISTRY', 'ArtifactSpec', 'provenance', 'read_artifact', 'sha256_of',
+    'write_artifact',
+]

common/artifacts.py

@@ -0,0 +1,72 @@
+"""Artifact provenance stamping and the generator/artifact registry."""
+import hashlib
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional, Tuple
+
+from .paths import REPO
+
+
+@dataclass(frozen=True)
+class ArtifactSpec:
+    """Owning script, source pool, and required top-level payload keys."""
+
+    generator: Optional[str]
+    pool: Optional[str]
+    payload_keys: Tuple[str, ...]
+    note: str = ''
+
+
+NO_GENERATOR = 'discovery sweep not committed; no producer for this file in the repo'
+
+REGISTRY = {
+    'eval.json': ArtifactSpec('verify.py', 'VAL5000', ('metrics',)),
+    'eval_tight_fpr.json': ArtifactSpec(
+        'verify.py', None,
+        ('metrics', 'prop_false_positive_rate', 'baseline')),
+    'discovery/dim_selection.json': ArtifactSpec(None, None, (), NO_GENERATOR),
+    'discovery/dim48_characterization.json': ArtifactSpec(None, None, (), NO_GENERATOR),
+    'discovery/prop_specificity.json': ArtifactSpec(None, None, (), NO_GENERATOR),
+    'discovery/prop_image_manifest.json': ArtifactSpec(None, None, (), NO_GENERATOR),
+    'discovery/variant_leaderboard.json': ArtifactSpec(None, None, (), NO_GENERATOR),
+    'per_dim_thresholds.json': ArtifactSpec(
+        'calibrate.py', 'BALANCED_VAL',
+        ('quant_scale', 'per_dim_thresholds', 'popcount', 'additive',
+         'F1_delta_popcount_vs_additive')),
+    'circuit.json': ArtifactSpec('synth.py', None, ('variants', 'accuracy')),
+}
+
+
+def sha256_of(path) -> str:
+    """Content hash of a file."""
+    return hashlib.sha256(Path(path).read_bytes()).hexdigest()
+
+
+def provenance(generator: str, classifier=None, pool_info: Optional[dict] = None,
+               **extra) -> dict:
+    """Assemble a provenance block from repository-recoverable fields only."""
+    block = {'generator': generator}
+    if classifier is not None:
+        path = Path(classifier)
+        block['classifier'] = str(path.resolve().relative_to(REPO)).replace('\\', '/')
+        block['classifier_sha256'] = sha256_of(path)
+    if pool_info:
+        block.update(pool_info)
+    block.update(extra)
+    return block
+
+
+def write_artifact(path, payload: dict, *, generator: str, classifier=None,
+                   pool_info: Optional[dict] = None, compact: bool = False, **extra):
+    """Write `payload` beneath a provenance block and return the document."""
+    doc = {'provenance': provenance(generator, classifier, pool_info, **extra)}
+    doc.update(payload)
+    sep = (',', ':') if compact else None
+    text = json.dumps(doc, indent=None if compact else 2, separators=sep)
+    Path(path).write_text(text + ('' if compact else '\n'), encoding='utf-8')
+    return doc
+
+
+def read_artifact(path) -> dict:
+    return json.loads(Path(path).read_text(encoding='utf-8'))

common/data.py

@@ -0,0 +1,77 @@
+"""COCO loading and input normalization.
+
+Images are resized to a square `resolution` with bilinear interpolation and
+normalized with ImageNet statistics, matching the protocol every stage was
+measured under.
+"""
+from pathlib import Path
+from typing import Iterable, List, Sequence, Tuple, Union
+
+import numpy as np
+import torch
+from PIL import Image
+
+from .paths import COCO_ROOT
+
+MEAN = (0.485, 0.456, 0.406)
+STD = (0.229, 0.224, 0.225)
+PERSON_CATEGORY_ID = 1
+
+
+def _stats(device: str) -> Tuple[torch.Tensor, torch.Tensor]:
+    mean = torch.tensor(MEAN).view(1, 3, 1, 1).to(device)
+    std = torch.tensor(STD).view(1, 3, 1, 1).to(device)
+    return mean, std
+
+
+def normalize(img: Image.Image, resolution: int, device: str) -> torch.Tensor:
+    """PIL image -> (1, 3, R, R) normalized float tensor."""
+    img = img.convert('RGB').resize((resolution, resolution), Image.BILINEAR)
+    arr = np.asarray(img, dtype=np.uint8).copy()
+    x = torch.from_numpy(arr).permute(2, 0, 1).unsqueeze(0).to(device).float() / 255.0
+    mean, std = _stats(device)
+    return (x - mean) / std
+
+
+def load_image(image: Union[str, Path, Image.Image, np.ndarray, torch.Tensor],
+               resolution: int, device: str) -> torch.Tensor:
+    """Accept a path, PIL image, HWC array, or CHW tensor; return a batch of 1."""
+    if isinstance(image, (str, Path)):
+        img = Image.open(image)
+    elif isinstance(image, Image.Image):
+        img = image
+    elif isinstance(image, np.ndarray):
+        img = Image.fromarray(image)
+    elif isinstance(image, torch.Tensor):
+        arr = image.cpu().numpy() if image.ndim == 3 else image[0].cpu().numpy()
+        if arr.shape[0] == 3:
+            arr = arr.transpose(1, 2, 0)
+        img = Image.fromarray((arr * 255).astype('uint8'))
+    else:
+        raise TypeError(f'unsupported image type: {type(image)}')
+    return normalize(img, resolution, device)
+
+
+def coco_split(split: str = 'val2017'):
+    """Return (COCO handle, image-file lookup) for a COCO split."""
+    from pycocotools.coco import COCO
+    coco = COCO(str(COCO_ROOT / 'annotations' / f'instances_{split}.json'))
+    id_to_file = {i['id']: i['file_name'] for i in coco.loadImgs(coco.getImgIds())}
+    return coco, id_to_file
+
+
+def person_labels(coco, img_ids: Sequence[int], device: str = 'cpu') -> torch.Tensor:
+    """Image-level person presence for each id, as a bool tensor."""
+    labels = [
+        any(a['category_id'] == PERSON_CATEGORY_ID
+            for a in coco.loadAnns(coco.getAnnIds(imgIds=i, iscrowd=False)))
+        for i in img_ids
+    ]
+    return torch.tensor(labels, dtype=torch.bool, device=device)
+
+
+def image_paths(id_to_file: dict, img_ids: Iterable[int],
+                split: str = 'val2017') -> List[Path]:
+    """Absolute paths for a sequence of image ids within a split."""
+    root = COCO_ROOT / split
+    return [root / id_to_file[i] for i in img_ids]

common/features.py

@@ -0,0 +1,52 @@
+"""Pooled feature extraction and the ternary scoring rule.
+
+The classifier reads one 768-D vector per image: layernorm across the 768
+channels of every patch token, then max-pool across the 2304 patches. Score is
+the sum of the person-positive dims minus the sum of the person-negative dims.
+"""
+from typing import Optional, Sequence
+
+import torch
+import torch.nn.functional as F
+
+D = 768
+RES = 768
+
+
+def pool(patch_tokens: torch.Tensor) -> torch.Tensor:
+    """(N, D) or (B, N, D) patch tokens -> (D,) or (B, D) pooled vector."""
+    ln = F.layer_norm(patch_tokens.float(), [D])
+    return ln.max(dim=-2).values
+
+
+@torch.inference_mode()
+def backbone_pooled(backbone, x: torch.Tensor, autocast: bool = True) -> torch.Tensor:
+    """Forward a normalized batch through the backbone and pool it."""
+    if autocast:
+        dev = 'cuda' if x.is_cuda else 'cpu'
+        with torch.autocast(dev, dtype=torch.bfloat16):
+            out = backbone.forward_features(x)
+    else:
+        out = backbone.forward_features(x)
+    return pool(out['x_norm_patchtokens'].float())
+
+
+def score(pooled: torch.Tensor, pos: Sequence[int], neg: Sequence[int]) -> torch.Tensor:
+    """sum(pooled[pos]) - sum(pooled[neg]), over the last axis."""
+    if not torch.is_tensor(pos):
+        pos = torch.tensor(list(pos), dtype=torch.long, device=pooled.device)
+    if not torch.is_tensor(neg):
+        neg = torch.tensor(list(neg), dtype=torch.long, device=pooled.device)
+    return pooled.index_select(-1, pos).sum(-1) - pooled.index_select(-1, neg).sum(-1)
+
+
+def score_pool(backbone, loaded, pos, neg, target_dims: Optional[torch.Tensor] = None):
+    """Score a pool; with `target_dims`, also return the pooled activations there."""
+    scores, targets = [], []
+    for x in loaded:
+        pooled = backbone_pooled(backbone, x)[0]
+        scores.append(score(pooled, pos, neg))
+        if target_dims is not None:
+            targets.append(pooled[target_dims])
+    stacked = torch.stack(scores)
+    return (stacked, torch.stack(targets)) if target_dims is not None else (stacked, None)

common/metrics.py

@@ -0,0 +1,47 @@
+"""Binary classification metrics, single-sourced so every stage scores identically."""
+from typing import NamedTuple
+
+import torch
+
+
+class Metrics(NamedTuple):
+    """F1, precision, recall, and the threshold they were measured at."""
+
+    f1: float
+    precision: float
+    recall: float
+    threshold: float = float('nan')
+
+    def asdict(self) -> dict:
+        d = {'F1': self.f1, 'precision': self.precision, 'recall': self.recall}
+        if self.threshold == self.threshold:  # excludes NaN
+            d['threshold'] = self.threshold
+        return d
+
+
+def prf1(pred: torch.Tensor, labels: torch.Tensor) -> Metrics:
+    """Metrics for boolean prediction and label tensors."""
+    tp = (pred & labels).sum().float()
+    fp = (pred & ~labels).sum().float()
+    fn = (~pred & labels).sum().float()
+    precision = tp / (tp + fp).clamp(min=1)
+    recall = tp / (tp + fn).clamp(min=1)
+    f1 = 2 * precision * recall / (precision + recall).clamp(min=1e-9)
+    return Metrics(float(f1), float(precision), float(recall))
+
+
+def f1_at(scores: torch.Tensor, labels: torch.Tensor, threshold: float) -> Metrics:
+    """Metrics at a fixed threshold."""
+    return prf1(scores > threshold, labels)._replace(threshold=float(threshold))
+
+
+def f1_sweep(scores: torch.Tensor, labels: torch.Tensor, n_candidates: int = 500) -> Metrics:
+    """Best metrics over candidate thresholds drawn evenly from the sorted unique scores."""
+    uniq = torch.unique(scores).sort().values
+    stride = max(1, len(uniq) // n_candidates)
+    best = Metrics(0.0, 0.0, 0.0, 0.0)
+    for t in uniq.tolist()[::stride]:
+        m = prf1(scores > t, labels)
+        if m.f1 > best.f1:
+            best = m._replace(threshold=float(t))
+    return best

common/models.py

@@ -0,0 +1,32 @@
+"""Backbone loading."""
+import sys
+from pathlib import Path
+from typing import Optional
+
+from .paths import BACKBONE, BACKBONE_SRC
+
+_argus = None
+
+
+def argus_module():
+    """Import argus.py from the environment, BACKBONE_SRC, or the backbone repo."""
+    global _argus
+    if _argus is not None:
+        return _argus
+    try:
+        import argus
+    except ImportError:
+        if BACKBONE_SRC:
+            sys.path.insert(0, str(BACKBONE_SRC))
+        else:
+            from huggingface_hub import hf_hub_download
+            sys.path.insert(0, str(Path(hf_hub_download(BACKBONE, 'argus.py')).parent))
+        import argus
+    _argus = argus
+    return argus
+
+
+def load_backbone(repo: Optional[str] = None):
+    """Load the stock backbone in eval mode."""
+    from transformers import AutoModel
+    return AutoModel.from_pretrained(repo or BACKBONE, trust_remote_code=True).eval().backbone

common/paths.py

@@ -0,0 +1,25 @@
+"""Filesystem and repository locations, overridable by environment.
+
+BACKBONE      HF repo id or local path for the backbone wrapper (alias: ARGUS_PATH)
+BACKBONE_SRC  local directory supplying argus.py (alias: ARGUS_SRC)
+COCO_ROOT     dataset root holding annotations/, train2017/, val2017/
+DEVICE        torch device string
+"""
+import os
+from pathlib import Path
+
+REPO = Path(__file__).resolve().parent.parent
+
+UPSTREAM_BACKBONE = 'facebook/EUPE-ViT-B'
+BACKBONE = os.environ.get('BACKBONE') or os.environ.get('ARGUS_PATH') or 'phanerozoic/argus'
+BACKBONE_SRC = os.environ.get('BACKBONE_SRC') or os.environ.get('ARGUS_SRC') or None
+COCO_ROOT = Path(os.environ.get('COCO_ROOT', '/home/zootest/datasets/coco'))
+
+ARGUS = BACKBONE
+
+
+def device() -> str:
+    if 'DEVICE' in os.environ:
+        return os.environ['DEVICE']
+    import torch
+    return 'cuda' if torch.cuda.is_available() else 'cpu'

common/pool.py

@@ -0,0 +1,72 @@
+"""Evaluation-pool loading."""
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterator, List, Optional
+
+import torch
+from PIL import Image
+
+from .data import coco_split, image_paths, normalize, person_labels
+from .features import RES
+from .pools import Pool
+
+
+@dataclass
+class LoadedPool:
+    """Image ids, paths and labels for one named pool, images optionally resident."""
+
+    pool: Pool
+    img_ids: List[int]
+    paths: List[Path]
+    labels: torch.Tensor
+    device: str
+    images: Optional[List[torch.Tensor]] = None
+
+    def __len__(self) -> int:
+        return len(self.img_ids)
+
+    def __iter__(self) -> Iterator[torch.Tensor]:
+        """Yield each image as a normalized (1, 3, RES, RES) tensor."""
+        if self.images is not None:
+            yield from self.images
+            return
+        for path in self.paths:
+            yield normalize(Image.open(path), RES, self.device)
+
+    @property
+    def positive_rate(self) -> float:
+        return round(self.labels.float().mean().item(), 4)
+
+    def provenance(self) -> dict:
+        """Pool fields recorded in an artifact's provenance block."""
+        return {'pool': self.pool.name, 'split': self.pool.split,
+                'n_images': len(self), 'positive_rate': self.positive_rate,
+                'selection': self.pool.selection}
+
+
+def balanced_indices(labels: torch.Tensor, seed: int = 0) -> torch.Tensor:
+    """Indices subsampling `labels` to equal positive and negative counts, seeded."""
+    generator = torch.Generator(device='cpu').manual_seed(seed)
+    cpu = labels.cpu()
+    pos = cpu.nonzero(as_tuple=True)[0]
+    neg = (~cpu).nonzero(as_tuple=True)[0]
+    n = min(len(pos), len(neg))
+    sel = torch.cat([pos[torch.randperm(len(pos), generator=generator)[:n]],
+                     neg[torch.randperm(len(neg), generator=generator)[:n]]])
+    return sel[torch.randperm(len(sel), generator=generator)]
+
+
+def load_pool(pool: Pool, device: str, preload: bool = False, seed: int = 0) -> LoadedPool:
+    """Resolve a named pool to ids, paths and labels; `preload` holds images in memory."""
+    coco, id_to_file = coco_split(pool.split)
+    img_ids = sorted(coco.getImgIds())
+    if pool.n is not None:
+        img_ids = img_ids[:pool.n]
+    labels = person_labels(coco, img_ids, device)
+    if pool.balanced:
+        sel = balanced_indices(labels, seed)
+        img_ids = [img_ids[i] for i in sel.tolist()]
+        labels = labels[sel.to(labels.device)]
+    paths = image_paths(id_to_file, img_ids, pool.split)
+    images = [normalize(Image.open(p), RES, device) for p in paths] if preload else None
+    return LoadedPool(pool, img_ids, paths, labels, device, images)

common/pools.py

@@ -0,0 +1,36 @@
+"""Named evaluation pools, cited by name in every artifact's provenance block."""
+from typing import NamedTuple, Optional
+
+
+class Pool(NamedTuple):
+    name: str
+    split: str
+    n: Optional[int]
+    balanced: bool
+    selection: str
+
+
+VAL5000 = Pool(
+    'VAL5000', 'val2017', 5000, False,
+    'the first 5000 val2017 image ids in sorted order, which is the whole split')
+
+CALIB1000 = Pool(
+    'CALIB1000', 'val2017', 1000, False,
+    'the first 1000 val2017 image ids in sorted order')
+
+VAL500 = Pool(
+    'VAL500', 'val2017', 500, False,
+    'the first 500 val2017 image ids in sorted order')
+
+BALANCED_VAL = Pool(
+    'BALANCED_VAL', 'val2017', None, True,
+    'val2017 subsampled without replacement to equal person-positive and '
+    'person-negative counts')
+
+POOLS = {p.name: p for p in (VAL5000, CALIB1000, VAL500, BALANCED_VAL)}
+
+
+def by_name(name: str) -> Pool:
+    if name not in POOLS:
+        raise ValueError(f'unknown pool {name!r}; expected one of {sorted(POOLS)}')
+    return POOLS[name]

discovery/dim48_characterization.json

@@ -0,0 +1,546 @@
+{
+  "provenance": {
+    "generator": null,
+    "note": "discovery sweep not committed; no producer in the repo"
+  },
+  "target_dim": 48,
+  "A_f1_vs_k": [
+    {
+      "K": 1,
+      "F1": 0.8285356163978577,
+      "precision": 0.7985524535179138,
+      "recall": 0.8608582615852356,
+      "dims": [
+        48
+      ]
+    },
+    {
+      "K": 2,
+      "F1": 0.8562204241752625,
+      "precision": 0.8503633737564087,
+      "recall": 0.8621586561203003,
+      "dims": [
+        48,
+        525
+      ]
+    },
+    {
+      "K": 3,
+      "F1": 0.8652572631835938,
+      "precision": 0.8526936173439026,
+      "recall": 0.8781967759132385,
+      "dims": [
+        48,
+        525,
+        475
+      ]
+    },
+    {
+      "K": 5,
+      "F1": 0.8649698495864868,
+      "precision": 0.8608844876289368,
+      "recall": 0.8690940737724304,
+      "dims": [
+        48,
+        525,
+        475,
+        323,
+        240
+      ]
+    },
+    {
+      "K": 10,
+      "F1": 0.9092138409614563,
+      "precision": 0.9465290904045105,
+      "recall": 0.8747290968894958,
+      "dims": [
+        48,
+        525,
+        475,
+        323,
+        240,
+        "..."
+      ]
+    },
+    {
+      "K": 20,
+      "F1": 0.9288457632064819,
+      "precision": 0.9698113203048706,
+      "recall": 0.8912007212638855,
+      "dims": [
+        48,
+        525,
+        475,
+        323,
+        240,
+        "..."
+      ]
+    },
+    {
+      "K": 30,
+      "F1": 0.9349648356437683,
+      "precision": 0.9795821309089661,
+      "recall": 0.8942349553108215,
+      "dims": [
+        48,
+        525,
+        475,
+        323,
+        240,
+        "..."
+      ]
+    },
+    {
+      "K": 50,
+      "F1": 0.9407240152359009,
+      "precision": 0.9839091300964355,
+      "recall": 0.9011703729629517,
+      "dims": [
+        48,
+        525,
+        475,
+        323,
+        240,
+        "..."
+      ]
+    },
+    {
+      "K": 92,
+      "F1": 0.9444695711135864,
+      "precision": 0.98539799451828,
+      "recall": 0.9068053960800171,
+      "dims": [
+        48,
+        525,
+        475,
+        323,
+        240,
+        "..."
+      ]
+    },
+    {
+      "K": 184,
+      "F1": 0.9485046863555908,
+      "precision": 0.9855140447616577,
+      "recall": 0.9141742587089539,
+      "dims": [
+        48,
+        525,
+        475,
+        323,
+        240,
+        "..."
+      ]
+    }
+  ],
+  "B_dim48_distribution": {
+    "person_pos": {
+      "n": 2693,
+      "mean": 8.113646507263184,
+      "std": 2.3924715518951416,
+      "min": -1.2812166213989258,
+      "p25": 7.193147659301758,
+      "p50": 8.808687210083008,
+      "p75": 9.730491638183594,
+      "max": 12.061566352844238
+    },
+    "person_neg": {
+      "n": 2307,
+      "mean": 2.982386589050293,
+      "std": 2.7675836086273193,
+      "min": -3.072082042694092,
+      "p25": 0.5744761228561401,
+      "p50": 3.059739589691162,
+      "p75": 5.2233123779296875,
+      "max": 11.300838470458984
+    },
+    "separation_cohen_d": 1.983604907989502
+  },
+  "C_per_class_top15": [
+    {
+      "class": "person",
+      "cat_id": 1,
+      "n_imgs": 2693,
+      "dim48_mean_inclass": 8.1136474609375,
+      "dim48_mean_outclass": 2.982386350631714,
+      "delta": 5.131261110305786
+    },
+    {
+      "class": "tennis racket",
+      "cat_id": 43,
+      "n_imgs": 167,
+      "dim48_mean_inclass": 9.163715362548828,
+      "dim48_mean_outclass": 5.627990245819092,
+      "delta": 3.5357251167297363
+    },
+    {
+      "class": "tie",
+      "cat_id": 32,
+      "n_imgs": 145,
+      "dim48_mean_inclass": 8.980120658874512,
+      "dim48_mean_outclass": 5.6494951248168945,
+      "delta": 3.330625534057617
+    },
+    {
+      "class": "baseball glove",
+      "cat_id": 40,
+      "n_imgs": 100,
+      "dim48_mean_inclass": 8.982823371887207,
+      "dim48_mean_outclass": 5.680027008056641,
+      "delta": 3.3027963638305664
+    },
+    {
+      "class": "skateboard",
+      "cat_id": 41,
+      "n_imgs": 127,
+      "dim48_mean_inclass": 8.923754692077637,
+      "dim48_mean_outclass": 5.663267135620117,
+      "delta": 3.2604875564575195
+    },
+    {
+      "class": "baseball bat",
+      "cat_id": 39,
+      "n_imgs": 97,
+      "dim48_mean_inclass": 8.886703491210938,
+      "dim48_mean_outclass": 5.683949947357178,
+      "delta": 3.2027535438537598
+    },
+    {
+      "class": "backpack",
+      "cat_id": 27,
+      "n_imgs": 228,
+      "dim48_mean_inclass": 8.655838012695312,
+      "dim48_mean_outclass": 5.607059001922607,
+      "delta": 3.048779010772705
+    },
+    {
+      "class": "remote",
+      "cat_id": 75,
+      "n_imgs": 145,
+      "dim48_mean_inclass": 8.703699111938477,
+      "dim48_mean_outclass": 5.657751083374023,
+      "delta": 3.045948028564453
+    },
+    {
+      "class": "toothbrush",
+      "cat_id": 90,
+      "n_imgs": 34,
+      "dim48_mean_inclass": 8.746152877807617,
+      "dim48_mean_outclass": 5.725543022155762,
+      "delta": 3.0206098556518555
+    },
+    {
+      "class": "handbag",
+      "cat_id": 31,
+      "n_imgs": 292,
+      "dim48_mean_inclass": 8.576542854309082,
+      "dim48_mean_outclass": 5.570532321929932,
+      "delta": 3.0060105323791504
+    },
+    {
+      "class": "sports ball",
+      "cat_id": 37,
+      "n_imgs": 169,
+      "dim48_mean_inclass": 8.645074844360352,
+      "dim48_mean_outclass": 5.644669532775879,
+      "delta": 3.0004053115844727
+    },
+    {
+      "class": "hair drier",
+      "cat_id": 89,
+      "n_imgs": 9,
+      "dim48_mean_inclass": 8.637924194335938,
+      "dim48_mean_outclass": 5.74086856842041,
+      "delta": 2.8970556259155273
+    },
+    {
+      "class": "skis",
+      "cat_id": 35,
+      "n_imgs": 120,
+      "dim48_mean_inclass": 8.562700271606445,
+      "dim48_mean_outclass": 5.676822185516357,
+      "delta": 2.885878086090088
+    },
+    {
+      "class": "cell phone",
+      "cat_id": 77,
+      "n_imgs": 214,
+      "dim48_mean_inclass": 8.483532905578613,
+      "dim48_mean_outclass": 5.623681545257568,
+      "delta": 2.859851360321045
+    },
+    {
+      "class": "snowboard",
+      "cat_id": 36,
+      "n_imgs": 49,
+      "dim48_mean_inclass": 8.451048851013184,
+      "dim48_mean_outclass": 5.71931266784668,
+      "delta": 2.731736183166504
+    }
+  ],
+  "C_per_class_bottom15": [
+    {
+      "class": "traffic light",
+      "cat_id": 10,
+      "n_imgs": 191,
+      "dim48_mean_inclass": 4.146858215332031,
+      "dim48_mean_outclass": 5.809599876403809,
+      "delta": -1.6627416610717773
+    },
+    {
+      "class": "boat",
+      "cat_id": 9,
+      "n_imgs": 121,
+      "dim48_mean_inclass": 4.040976047515869,
+      "dim48_mean_outclass": 5.788370132446289,
+      "delta": -1.74739408493042
+    },
+    {
+      "class": "fire hydrant",
+      "cat_id": 11,
+      "n_imgs": 86,
+      "dim48_mean_inclass": 3.6824471950531006,
+      "dim48_mean_outclass": 5.782199382781982,
+      "delta": -2.099752187728882
+    },
+    {
+      "class": "clock",
+      "cat_id": 85,
+      "n_imgs": 204,
+      "dim48_mean_inclass": 3.664764642715454,
+      "dim48_mean_outclass": 5.83461332321167,
+      "delta": -2.169848680496216
+    },
+    {
+      "class": "train",
+      "cat_id": 7,
+      "n_imgs": 157,
+      "dim48_mean_inclass": 3.4102745056152344,
+      "dim48_mean_outclass": 5.821805477142334,
+      "delta": -2.4115309715270996
+    },
+    {
+      "class": "sheep",
+      "cat_id": 20,
+      "n_imgs": 65,
+      "dim48_mean_inclass": 3.174736261367798,
+      "dim48_mean_outclass": 5.779951095581055,
+      "delta": -2.605214834213257
+    },
+    {
+      "class": "elephant",
+      "cat_id": 22,
+      "n_imgs": 89,
+      "dim48_mean_inclass": 3.023428201675415,
+      "dim48_mean_outclass": 5.795424938201904,
+      "delta": -2.7719967365264893
+    },
+    {
+      "class": "parking meter",
+      "cat_id": 14,
+      "n_imgs": 37,
+      "dim48_mean_inclass": 2.688075065612793,
+      "dim48_mean_outclass": 5.768880844116211,
+      "delta": -3.080805778503418
+    },
+    {
+      "class": "airplane",
+      "cat_id": 5,
+      "n_imgs": 97,
+      "dim48_mean_inclass": 2.6694958209991455,
+      "dim48_mean_outclass": 5.806950092315674,
+      "delta": -3.1374542713165283
+    },
+    {
+      "class": "stop sign",
+      "cat_id": 13,
+      "n_imgs": 69,
+      "dim48_mean_inclass": 2.509443998336792,
+      "dim48_mean_outclass": 5.7913737297058105,
+      "delta": -3.2819297313690186
+    },
+    {
+      "class": "cow",
+      "cat_id": 21,
+      "n_imgs": 87,
+      "dim48_mean_inclass": 2.1573596000671387,
+      "dim48_mean_outclass": 5.809632778167725,
+      "delta": -3.652273178100586
+    },
+    {
+      "class": "bird",
+      "cat_id": 16,
+      "n_imgs": 125,
+      "dim48_mean_inclass": 1.5200526714324951,
+      "dim48_mean_outclass": 5.854443073272705,
+      "delta": -4.33439040184021
+    },
+    {
+      "class": "giraffe",
+      "cat_id": 25,
+      "n_imgs": 101,
+      "dim48_mean_inclass": 0.5355944633483887,
+      "dim48_mean_outclass": 5.8535051345825195,
+      "delta": -5.317910671234131
+    },
+    {
+      "class": "zebra",
+      "cat_id": 24,
+      "n_imgs": 85,
+      "dim48_mean_inclass": 0.19826489686965942,
+      "dim48_mean_outclass": 5.842027187347412,
+      "delta": -5.643762290477753
+    },
+    {
+      "class": "bear",
+      "cat_id": 23,
+      "n_imgs": 49,
+      "dim48_mean_inclass": -0.3452981412410736,
+      "dim48_mean_outclass": 5.806369781494141,
+      "delta": -6.151667922735214
+    }
+  ],
+  "D_top10_correlation": {
+    "dims": [
+      48,
+      525,
+      475,
+      323,
+      240,
+      637,
+      318,
+      472,
+      719,
+      251
+    ],
+    "corr_matrix": [
+      [
+        1.000000238418579,
+        0.28202927112579346,
+        -0.03376583009958267,
+        0.24143743515014648,
+        -0.013180982321500778,
+        0.1519388109445572,
+        0.21512284874916077,
+        0.12231583148241043,
+        0.15586860477924347,
+        0.14881354570388794
+      ],
+      [
+        0.28202927112579346,
+        0.9999998211860657,
+        0.2280241698026657,
+        0.08577030897140503,
+        0.20908223092556,
+        -0.09965874999761581,
+        0.2280401587486267,
+        0.08895031362771988,
+        0.2658396065235138,
+        -0.15059183537960052
+      ],
+      [
+        -0.03376583009958267,
+        0.2280241698026657,
+        1.0000001192092896,
+        0.061812229454517365,
+        0.570030927658081,
+        -0.011771553196012974,
+        0.07696891576051712,
+        -0.10601639002561569,
+        0.06801445037126541,
+        -0.23264755308628082
+      ],
+      [
+        0.24143743515014648,
+        0.08577030897140503,
+        0.061812229454517365,
+        0.9999997615814209,
+        0.0030930074863135815,
+        0.18994615972042084,
+        0.15969695150852203,
+        0.21833136677742004,
+        0.26542553305625916,
+        -0.039861708879470825
+      ],
+      [
+        -0.013180982321500778,
+        0.20908223092556,
+        0.570030927658081,
+        0.0030930074863135815,
+        1.0000003576278687,
+        -0.09009360522031784,
+        0.003698738757520914,
+        -0.08297917991876602,
+        0.01635875552892685,
+        -0.21284666657447815
+      ],
+      [
+        0.1519388109445572,
+        -0.09965874999761581,
+        -0.011771553196012974,
+        0.18994615972042084,
+        -0.09009360522031784,
+        0.9999999403953552,
+        0.13532496988773346,
+        0.04327913001179695,
+        -0.03058011643588543,
+        0.22757190465927124
+      ],
+      [
+        0.21512284874916077,
+        0.2280401587486267,
+        0.07696891576051712,
+        0.15969695150852203,
+        0.003698738757520914,
+        0.13532496988773346,
+        0.9999998807907104,
+        0.030232839286327362,
+        0.23005540668964386,
+        0.025300158187747
+      ],
+      [
+        0.12231583148241043,
+        0.08895031362771988,
+        -0.10601639002561569,
+        0.21833136677742004,
+        -0.08297917991876602,
+        0.04327913001179695,
+        0.030232839286327362,
+        1.000000238418579,
+        0.21879234910011292,
+        0.020776957273483276
+      ],
+      [
+        0.15586860477924347,
+        0.2658396065235138,
+        0.06801445037126541,
+        0.26542553305625916,
+        0.01635875552892685,
+        -0.03058011643588543,
+        0.23005540668964386,
+        0.21879234910011292,
+        0.9999998807907104,
+        -0.015971055254340172
+      ],
+      [
+        0.14881354570388794,
+        -0.15059183537960052,
+        -0.23264755308628082,
+        -0.039861708879470825,
+        -0.21284666657447815,
+        0.22757190465927124,
+        0.025300158187747,
+        0.020776957273483276,
+        -0.015971055254340172,
+        1.0000001192092896
+      ]
+    ],
+    "max_abs_offdiag": 0.570030927658081
+  },
+  "E_spatial_localization": {
+    "n_sampled_images": 500,
+    "mean_iou": 0.16534487868892028,
+    "median_iou": 0.15606729686260223,
+    "p95_iou": 0.35281437188386916
+  }
+}

discovery/dim_selection.json

@@ -0,0 +1,504 @@
+{
+  "provenance": {
+    "generator": null,
+    "note": "discovery sweep not committed; no producer in the repo"
+  },
+  "n_sampled": 100000,
+  "K": 92,
+  "n_kept": 1000,
+  "f1_distribution": {
+    "min": 0.7833036780357361,
+    "p50": 0.8676828145980835,
+    "p95": 0.9258173704147339,
+    "p99": 0.9300636053085327,
+    "max": 0.9373591542243958
+  },
+  "top_kept_f1_range": [
+    0.9300652146339417,
+    0.9373591542243958
+  ],
+  "best_single_genome_f1": 0.9373591542243958,
+  "best_single_genome_sorted": [
+    2,
+    4,
+    8,
+    21,
+    29,
+    39,
+    48,
+    67,
+    69,
+    75,
+    91,
+    119,
+    124,
+    141,
+    149,
+    157,
+    158,
+    168,
+    177,
+    181,
+    192,
+    198,
+    200,
+    218,
+    220,
+    240,
+    249,
+    250,
+    259,
+    267,
+    269,
+    272,
+    273,
+    275,
+    285,
+    286,
+    297,
+    300,
+    304,
+    318,
+    319,
+    323,
+    328,
+    330,
+    340,
+    373,
+    374,
+    377,
+    379,
+    391,
+    393,
+    403,
+    419,
+    429,
+    433,
+    436,
+    454,
+    463,
+    476,
+    520,
+    524,
+    530,
+    537,
+    548,
+    550,
+    558,
+    560,
+    570,
+    574,
+    582,
+    590,
+    594,
+    605,
+    606,
+    609,
+    612,
+    617,
+    624,
+    630,
+    646,
+    649,
+    657,
+    660,
+    673,
+    680,
+    700,
+    715,
+    716,
+    737,
+    740,
+    754,
+    755
+  ],
+  "dim_frequency_top_25": {
+    "48": 1.0,
+    "525": 0.3140000104904175,
+    "475": 0.3110000193119049,
+    "323": 0.23400001227855682,
+    "240": 0.21700000762939453,
+    "637": 0.2120000123977661,
+    "318": 0.20600001513957977,
+    "472": 0.20200000703334808,
+    "719": 0.20100000500679016,
+    "251": 0.19700001180171967,
+    "506": 0.19500000774860382,
+    "13": 0.1940000057220459,
+    "281": 0.1900000125169754,
+    "113": 0.1860000044107437,
+    "331": 0.1860000044107437,
+    "224": 0.18200001120567322,
+    "382": 0.1810000091791153,
+    "767": 0.18000000715255737,
+    "605": 0.1770000010728836,
+    "642": 0.17500001192092896,
+    "157": 0.17400000989437103,
+    "155": 0.1680000126361847,
+    "273": 0.16700001060962677,
+    "207": 0.16500000655651093,
+    "510": 0.16500000655651093
+  },
+  "union_classifier": {
+    "n_dims": 768,
+    "F1": 0.9616926908493042,
+    "precision": 0.989005982875824,
+    "recall": 0.9358474016189575
+  },
+  "cores": {
+    "23": [
+      48,
+      525,
+      475,
+      323,
+      240,
+      637,
+      318,
+      472,
+      719,
+      251,
+      506,
+      13,
+      281,
+      113,
+      331,
+      224,
+      382,
+      767,
+      605,
+      642,
+      157,
+      155,
+      273
+    ],
+    "46": [
+      48,
+      525,
+      475,
+      323,
+      240,
+      637,
+      318,
+      472,
+      719,
+      251,
+      506,
+      13,
+      281,
+      113,
+      331,
+      224,
+      382,
+      767,
+      605,
+      642,
+      157,
+      155,
+      273,
+      207,
+      510,
+      127,
+      245,
+      759,
+      292,
+      531,
+      617,
+      333,
+      527,
+      45,
+      332,
+      574,
+      595,
+      269,
+      158,
+      432,
+      0,
+      119,
+      310,
+      490,
+      557,
+      528
+    ],
+    "92": [
+      48,
+      525,
+      475,
+      323,
+      240,
+      637,
+      318,
+      472,
+      719,
+      251,
+      506,
+      13,
+      281,
+      113,
+      331,
+      224,
+      382,
+      767,
+      605,
+      642,
+      157,
+      155,
+      273,
+      207,
+      510,
+      127,
+      245,
+      759,
+      292,
+      531,
+      617,
+      333,
+      527,
+      45,
+      332,
+      574,
+      595,
+      269,
+      158,
+      432,
+      0,
+      119,
+      310,
+      490,
+      557,
+      528,
+      545,
+      558,
+      597,
+      645,
+      28,
+      51,
+      79,
+      82,
+      301,
+      126,
+      542,
+      173,
+      90,
+      380,
+      71,
+      384,
+      514,
+      620,
+      630,
+      713,
+      223,
+      516,
+      520,
+      606,
+      17,
+      172,
+      355,
+      393,
+      421,
+      745,
+      68,
+      252,
+      280,
+      334,
+      657,
+      95,
+      111,
+      151,
+      244,
+      543,
+      748,
+      290,
+      363,
+      469,
+      561,
+      591
+    ],
+    "184": [
+      48,
+      525,
+      475,
+      323,
+      240,
+      637,
+      318,
+      472,
+      719,
+      251,
+      506,
+      13,
+      281,
+      113,
+      331,
+      224,
+      382,
+      767,
+      605,
+      642,
+      157,
+      155,
+      273,
+      207,
+      510,
+      127,
+      245,
+      759,
+      292,
+      531,
+      617,
+      333,
+      527,
+      45,
+      332,
+      574,
+      595,
+      269,
+      158,
+      432,
+      0,
+      119,
+      310,
+      490,
+      557,
+      528,
+      545,
+      558,
+      597,
+      645,
+      28,
+      51,
+      79,
+      82,
+      301,
+      126,
+      542,
+      173,
+      90,
+      380,
+      71,
+      384,
+      514,
+      620,
+      630,
+      713,
+      223,
+      516,
+      520,
+      606,
+      17,
+      172,
+      355,
+      393,
+      421,
+      745,
+      68,
+      252,
+      280,
+      334,
+      657,
+      95,
+      111,
+      151,
+      244,
+      543,
+      748,
+      290,
+      363,
+      469,
+      561,
+      591,
+      96,
+      397,
+      419,
+      425,
+      523,
+      627,
+      734,
+      124,
+      236,
+      454,
+      9,
+      345,
+      358,
+      480,
+      575,
+      736,
+      26,
+      34,
+      65,
+      141,
+      152,
+      176,
+      204,
+      293,
+      305,
+      445,
+      282,
+      389,
+      437,
+      619,
+      162,
+      178,
+      311,
+      394,
+      409,
+      483,
+      496,
+      613,
+      717,
+      50,
+      188,
+      216,
+      325,
+      602,
+      699,
+      740,
+      254,
+      258,
+      299,
+      403,
+      495,
+      603,
+      622,
+      40,
+      83,
+      146,
+      150,
+      232,
+      259,
+      341,
+      392,
+      444,
+      522,
+      567,
+      629,
+      647,
+      25,
+      170,
+      205,
+      267,
+      274,
+      307,
+      411,
+      549,
+      576,
+      618,
+      686,
+      760,
+      8,
+      200,
+      255,
+      353,
+      354,
+      413,
+      455,
+      463,
+      544,
+      721,
+      93,
+      171,
+      225,
+      234
+    ]
+  },
+  "runtime_s": 4.635331869125366
+}

discovery/prop_image_manifest.json

@@ -0,0 +1 @@
+{"provenance":{"generator":null,"note":"discovery sweep not committed; no producer in the repo"},"source":"imagenet-1k train","filter":"YOLO26l, no person detected","person_conf_threshold":0.25,"total_kept":8479,"synsets":{"n04039381":"racket","n04591713":"Windsor_tie","n02883205":"bow_tie","n04254680":"soccer_ball","n04118538":"rugby_ball","n04228054":"ski","n02769748":"backpack","n03127747":"crash_helmet","n03124170":"cowboy_hat","n04259630":"sombrero","n03680355":"loafer","n03124043":"cowboy_boot","n03838899":"oboe","n03249569":"drum","n04074963":"remote_control","n02676566":"acoustic_guitar","n03272010":"electric_guitar","n04152593":"screen","n04590129":"window_shade","n04418357":"theater_curtain"},"stats":{"racket":{"inspected":1300,"kept":357},"Windsor_tie":{"inspected":551,"kept":500},"bow_tie":{"inspected":1300,"kept":242},"soccer_ball":{"inspected":1134,"kept":500},"rugby_ball":{"inspected":1300,"kept":149},"ski":{"inspected":1300,"kept":225},"backpack":{"inspected":587,"kept":500},"crash_helmet":{"inspected":837,"kept":500},"cowboy_hat":{"inspected":1300,"kept":230},"sombrero":{"inspected":1300,"kept":298},"loafer":{"inspected":999,"kept":500},"cowboy_boot":{"inspected":960,"kept":500},"oboe":{"inspected":1300,"kept":478},"drum":{"inspected":918,"kept":500},"remote_control":{"inspected":646,"kept":500},"acoustic_guitar":{"inspected":690,"kept":500},"electric_guitar":{"inspected":791,"kept":500},"screen":{"inspected":579,"kept":500},"window_shade":{"inspected":566,"kept":500},"theater_curtain":{"inspected":797,"kept":500}},"note":"image_ids[synset][k] identifies <synset>/<synset>_<id>.JPEG","image_ids":{"n04039381":[10013,10090,10184,10347,10349,104,10470,10472,10498,10682,10705,10856,10924,10972,11033,11074,1123,11236,11364,11421,11426,11519,11553,11566,11643,1167,11709,11880,11969,12094,12117,12159,1222,12224,1223,12356,12411,12449,12538,12546,12576,12590,12632,12660,12663,12664,12679,12719,1283,12832,12925,13048,13068,13248,13369,13371,13404,13480,13489,13566,13677,13712,13714,13964,14134,14139,14144,14243,14362,14366,14468,14589,14918,14943,14993,15115,15133,15222,15254,15301,15338,15388,15489,15692,1575,15809,15941,15995,16015,16114,16119,16197,16257,16277,16279,16362,16364,16435,16507,16574,16580,16616,16646,1676,1683,16849,16860,16940,17014,17050,17104,17252,1737,17387,17418,17515,17536,17595,17717,17766,17854,18108,18125,18152,1817,18173,18227,18265,18282,18352,1843,18432,18514,18642,1874,18759,18773,18842,19076,19145,19172,19246,19248,19262,19270,19330,19361,19399,1948,19671,19782,19787,19853,19928,19936,19940,19943,19954,19956,19974,20065,20256,20287,20318,20355,20371,20608,20639,20689,20702,20840,20851,20917,20955,21241,21566,21573,21574,21608,21657,21988,22008,22143,22278,22459,22861,22957,23045,23055,23107,23170,23244,23255,23360,2421,2503,2591,2626,2741,2756,2765,2784,2901,2952,2965,30093,3015,30350,3236,32782,3297,3313,3322,3373,3410,35176,3530,3554,3635,37712,3778,3815,3854,38660,3888,3892,39462,3978,3992,4019,4064,4067,4068,4096,4108,4142,4160,41634,41798,4191,4248,4269,4343,4365,4367,4401,4442,44525,4477,4567,4579,4681,471,4716,4732,4771,481,48255,4863,4864,4881,4920,4937,5008,50596,5178,5189,5262,5274,5331,53338,5474,5587,571,5717,5767,5807,5967,597,5988,6044,6166,6205,6301,6317,6406,6441,6452,6473,6476,6525,6769,6788,6989,7077,71,7106,7161,7164,7166,7215,7252,7267,7292,7299,7388,7478,7505,7516,7525,7590,7619,7665,7708,7710,7770,7786,784,7884,7961,8011,8015,8023,8027,8072,8125,8129,813,8222,8310,8327,8393,8395,8409,8412,8423,8669,8772,8803,8813,8840,8969,8985,9058,9250,9282,9285,9306,9328,9338,9361,9377,9447,9593,963,9637,9905],"n04591713":[100,10035,10065,101,10109,1015,1035,10383,10440,1046,10469,10484,105,1051,10510,10525,10550,10569,10614,10629,10686,107,1070,10760,10795,108,1084,11,110,11182,1121,1126,11324,1138,11499,11504,11520,1155,11558,1160,11606,11621,1164,1172,11759,1191,121,1225,1237,124,1244,1251,12567,12569,1257,1260,127,12767,1277,128,1280,12876,1302,1310,1316,132,13234,1326,13283,13349,134,1344,1352,1353,13550,13589,13590,1361,1367,13696,1370,1374,1375,1390,1398,14,1401,1403,14045,1407,1411,14142,14192,14205,1428,1437,1440,14419,145,14540,14563,14579,14626,14630,14641,1468,1472,1473,14741,1476,14895,1496,1503,15073,15127,15172,15205,1524,15278,1531,15321,1548,1554,1566,1573,1587,1594,1601,1604,1606,16097,1610,1611,1615,1616,16175,1627,1630,1634,16352,16364,16396,1640,1643,16442,1649,1652,1658,1659,1660,16610,16654,1671,16710,16751,1679,16793,16805,1691,1692,1702,17048,17055,1713,1717,17170,17197,172,1728,1742,1744,17471,1752,17535,1755,1761,17618,1762,1764,1767,17676,1768,1773,1777,17776,1779,17826,1784,1786,179,1808,18116,1813,1814,18197,1822,1824,18281,183,1834,1836,1837,1848,18520,1857,1860,1876,1879,18806,1885,1893,18962,1900,1905,1908,19122,19169,19185,19198,1927,1930,1932,1935,1938,19409,19432,1952,1962,1969,197,1976,1978,1988,1989,1992,1993,2003,2010,2022,2024,2025,2026,2037,2038,2041,2042,2043,2047,2049,2052,2053,2058,2059,2063,2084,2088,2095,2116,2122,2123,2129,2131,2140,2144,215,2150,2154,2167,217,2170,2176,2178,2180,2194,2197,2199,2200,2212,2222,223,2233,2246,2252,2256,2259,2263,2271,2272,2288,2305,2310,2322,2327,2344,2345,2359,2362,2366,2369,2373,2419,2427,2432,2440,2448,2451,2456,2473,2479,2480,2485,25,2501,2506,2515,2525,2534,2537,2538,2549,2555,2557,2561,2566,2567,2569,2576,2589,2594,2605,261,2648,2666,2668,2676,2679,2680,2691,2694,2701,2713,2714,2718,2732,2740,2747,2753,2757,2760,2764,277,2775,2777,278,2787,2790,2793,2800,2802,2805,2808,2813,2817,2818,2826,2841,2842,2845,2848,2850,2852,2857,2879,2883,2899,2903,2918,2925,2938,2940,2952,2956,2957,2971,2972,2977,2978,2999,3002,3004,3010,3013,3016,3020,3022,3030,304,3052,3054,3069,3083,3085,3090,3093,3094,31,3104,3107,3112,3135,3139,3153,3158,3161,3174,3182,319,3191,3195,321,3214,3218,3242,3252,3255,3258,3260,3281,3284,3289,3291,3295,3299,3300,3309,3312,3315,3316,3327,3328,3332,3333,334,3343,3348,335,3358,3360,3370,3371,3376,3379,3393,3396,3399,3402,3404,3409,3410,3412,342,3420,3423,3429,3430,3438,3441,3442,3444,3448,3452,3454,3460,347,3470,3477,3488,3489,3491,3495,3496,3501,3502,3510,3513,3517,3522,353,3533,3534,3535,3544,3550,3554,356,3561,3562,3565,3568,3570],"n02883205":[102441,103964,10414,10423,10499,10716,10836,10868,10933,11249,11266,11268,11275,12209,1225,12313,12635,12683,12985,13214,13573,13679,13839,13978,14069,14134,14158,14395,14486,14489,14567,14710,14718,14865,15254,15261,15317,15665,1571,1594,15973,16052,16238,16384,169,17340,1737,17377,1747,17480,17589,17676,17712,1789,1795,1806,1815,18189,18414,18432,1877,18832,1949,20083,20091,202,20336,20342,20559,20564,20708,2076,2093,21117,2124,21243,21264,21385,21470,21733,2217,22630,22799,22977,23017,23066,2308,2316,23175,23241,23349,23381,23412,23469,23529,23570,23708,23785,23959,24058,24086,24104,24233,24303,24414,2452,25935,25983,26085,26218,26827,26901,27000,27266,27475,2762,2768,28828,29483,29518,29800,3013,30477,3075,30971,3112,31675,31689,3199,3203,3218,32945,33,33463,33605,3394,3440,34416,34466,3452,34807,34949,35920,36058,36300,36629,37159,3726,3773,38455,38463,38529,38590,39363,40402,40522,40637,40649,4089,41075,4111,41385,4174,41829,4247,429,431,43306,4407,44395,4445,44945,4495,4533,45414,45452,4560,46609,4704,47094,47843,48616,48715,4892,49319,4963,49642,50144,5015,5048,5155,51623,5585,5731,5739,5794,5802,5825,5841,5969,59905,6,6034,6053,6074,6098,6130,62028,6231,6252,63109,6343,6376,6458,6784,6860,6909,6912,6965,7047,7129,716,72227,7346,7497,7543,7721,7826,7877,7937,8052,8105,8229,8268,8368,8379,84107,8652,9003,9160,9291,9909],"n04254680":[10019,10043,10045,10049,10076,10112,10147,1015,10154,1016,10164,10170,10173,10190,10208,10241,1046,10460,10585,1060,1070,10747,10755,10766,10824,1090,10944,10992,1101,11026,11040,11069,1110,1113,11130,11201,11208,1131,11316,1137,11372,11404,11422,11443,1147,1150,11535,1160,11641,11751,11775,1184,1186,119,1190,1202,12086,12098,1220,1222,12287,1237,1240,1244,12455,1247,12484,1252,1253,1257,12573,12580,1264,1265,1266,1268,12724,1277,1279,1286,1295,1300,1305,1323,13233,13250,13251,13280,13307,13323,13379,13427,13436,1344,13449,13477,1352,1357,13623,1366,1376,13780,13803,13821,13898,1395,13987,1399,1401,14028,14038,1406,1411,14136,1424,14252,1430,1432,1434,14361,14369,1439,14417,14444,14687,14723,1473,1476,14812,14971,14994,1501,15039,1511,15224,15226,15240,15342,15422,1546,15590,157,1580,1584,1585,1591,15923,15943,1597,16005,16057,1607,16113,1613,1622,1627,1628,16425,1643,16523,1657,16593,16669,16734,1688,16966,16990,17123,17248,1740,1757,1759,18,1809,1824,1836,1848,1864,1892,190,1903,1904,1914,1926,1950,2005,2090,210,2107,2111,2116,2124,2155,2159,2202,2238,2270,2279,2282,2300,2302,2410,2413,2417,2422,2490,2551,2565,2585,2618,2637,2647,2667,2680,2772,2793,28,2812,2815,2868,294,2960,2968,2976,298,2984,3026,3061,3068,308,316,3164,32,324,3257,33,330,3300,3334,34,3413,3463,3495,3527,3541,3564,3617,3622,3715,376,3905,4023,404,4054,4065,4122,415,4164,4168,4181,422,4261,4279,4337,4344,437,4379,4422,4424,4452,4487,4510,4533,4586,4590,462,4627,4630,466,4667,467,4670,4697,4798,483,4877,4926,493,4941,4951,4956,4974,500,5002,5033,5079,5090,51,5100,5104,511,5120,5204,5260,5267,5276,5284,5301,5328,5334,5346,5349,5358,5368,5384,5387,539,5408,5415,5452,5458,5482,5517,5526,5530,5536,5553,5564,558,5584,559,5597,5598,5611,5613,5617,562,5621,5685,5719,5734,5744,577,579,581,5828,5860,5865,5901,5919,5934,5935,595,5985,5991,6019,6034,6039,6056,6061,6063,607,6086,6089,6096,6105,6152,6156,6161,6171,6182,6190,6209,6238,6252,6351,6368,6438,6470,6541,6544,656,6645,6711,6727,677,6813,6826,6915,6940,698,7078,7109,7146,7150,7184,7193,7226,7256,7260,7267,7280,73,7301,7311,7332,7338,7351,7355,7374,7410,7414,7437,7458,746,7474,7501,7514,7530,7560,7591,760,7607,763,7631,7668,7688,7701,7720,7722,7724,7726,7732,7733,7734,7755,7763,7779,7794,7810,7819,7822,7824,7830,7831,7844,7845,7846,7848,7851,7854,7892,7907,7908,7938,7939,794,7967,7986,7994,8013,8023,8027,8061,8063,8080,8095,8100,8107,8114,8126,8174,818,8197,8210,8235,824,8249,8257,8264,8266,8269,8274,8284,8293,8295,8319,8337,8338,8385,8411,8415,8419,8467,8475,8478,848,8506,854,857],"n04118538":[10198,10210,10219,10271,10466,1065,10755,10765,10921,11054,11096,11164,1119,11212,11270,1130,114,1146,11606,118,11850,11861,119,12229,12317,12341,12368,12599,12697,1288,1298,1346,13574,1369,13779,13853,13866,14011,14465,14536,147,15005,1510,1535,15451,15670,1571,15867,15991,16191,16198,1698,1736,17553,18495,1869,1935,19631,2022,20362,2107,21796,2276,2296,2302,234,24621,24875,2497,250,2755,2782,2858,2871,2926,3063,3066,3159,3272,3380,3482,358,3586,3623,3631,3637,3878,3943,3959,4054,4104,4121,4141,4150,4171,4184,4243,4284,4292,4361,4419,4525,4581,4628,4857,4881,4927,5200,5257,5291,5389,5419,5421,6114,6249,6328,6415,6467,6541,6566,6614,6648,6676,6803,6913,697,6978,7,7035,705,7198,7298,7375,7436,7507,756,7615,8031,809,85,8519,8592,8818,8937,9005,9049,9160,933,9823],"n04228054":[10244,10261,10306,10502,1057,10603,10755,10839,1084,10910,1096,10971,10973,10990,11041,1105,1127,11352,11353,11367,1144,11471,11535,11549,11638,11703,11767,11988,11992,120,12024,12050,12061,1225,1232,1303,13266,1328,13330,1345,1383,1395,13993,1434,145,1461,1479,15002,15024,1551,15676,15917,1596,16120,16211,16552,16629,16630,16933,16944,16946,1719,17548,17555,17607,1766,1813,18286,18398,19653,19675,20283,20378,2056,20634,20893,20970,21128,21413,21614,2185,2213,2259,2308,2324,2377,2395,2415,25016,2504,2521,2650,26843,2687,2693,2783,2860,2911,2994,30397,3058,30631,3080,3171,3172,3214,3217,3253,3319,3327,33610,34211,3454,3489,3519,3533,3538,3616,3718,3729,3817,3829,4142,4190,424,4417,4496,4503,4572,4578,462,4623,4744,4754,4794,48,4824,4833,4837,4838,4880,4900,4985,5022,5043,5073,5295,53,5396,5462,5501,556,5632,5686,5702,5877,5943,5977,6032,6033,613,6168,6206,6271,632,6332,6375,6414,66,6689,6695,6717,6782,693,701,7022,7116,7134,7157,7174,7209,7212,7302,7434,7455,7480,7526,7536,757,7626,7636,7667,7785,7886,7950,7989,8087,8116,8118,8177,8178,820,8218,8222,8325,84,8409,8413,8529,8873,904,929,931,9434,9509,9519,952,9590,9592,9611,9758,983,9835,9869,9998],"n02769748":[10023,10044,10045,100708,10089,101083,101091,101134,10135,10198,10204,10245,102866,103175,103198,1032,103229,10331,103341,103635,103643,103690,103716,103979,104665,10714,10791,10817,10922,10946,10986,11091,111,11144,11168,11236,11247,11248,11249,11277,11288,11293,11352,11373,1144,11443,11479,11744,1188,11946,12087,12149,1218,1220,12248,12336,12588,12727,12836,12871,12913,1295,1298,13046,13080,13105,1313,1319,13234,13273,13493,13551,1357,14060,14145,14180,14268,14315,14409,14510,14527,14540,1499,15053,15063,15153,15175,15269,15279,1528,15281,15310,15334,15342,15449,15456,15511,15571,15626,15635,15658,15669,15707,15813,15824,15844,15880,15914,15925,15964,16033,16048,16086,16206,16231,16326,16331,16366,1637,16376,1639,1641,16420,16431,1645,1651,16520,16613,16636,16701,16712,16802,16856,16875,1688,16882,16890,17001,17014,17033,17061,17099,17118,17135,1718,17192,17297,17338,17339,17433,17495,17548,17607,17655,17737,17748,17763,17779,178,17853,17858,17865,17927,17960,17977,17991,18011,18126,18129,18222,18245,1827,18275,18313,18321,18428,18446,18520,18543,18562,18564,18582,18656,18690,18841,18844,18852,18871,18874,18894,18956,18963,18987,19018,19085,19102,19188,19247,19268,19293,19300,19421,19502,19509,19510,19550,19586,19641,19662,19669,19678,19806,19938,1995,19957,2000,2001,20015,2016,20164,2053,20582,20635,20641,2065,20688,2072,20780,2082,2087,20903,2110,21174,21256,21293,21333,21335,2134,21392,21615,21685,21725,21834,2190,21984,2206,22069,22123,22130,2218,22227,22228,22260,22304,22388,2240,22445,2247,22486,22542,22689,22690,22705,22723,22726,2281,22813,22820,22921,22985,2300,23075,23085,23146,23197,23265,23270,23336,23377,23380,23468,23541,23542,23585,23754,2379,23828,23854,23878,2389,23898,24000,24012,24034,24048,24074,24142,242,24252,24293,24321,24449,24509,24514,2463,24665,24668,2472,24741,24743,2478,24785,2485,24873,250,25029,25169,25173,25223,25231,25236,25298,25344,25355,25467,25468,25561,25590,25606,25620,25684,2571,25747,25757,25841,2587,25894,25971,26073,26099,26109,26117,26152,26162,26173,26211,26302,26317,26346,26472,26542,26592,26626,26634,26644,26735,26776,26853,2688,26895,26941,26962,270,27044,27327,27402,27478,27516,27519,27616,2762,27717,27730,2774,27783,27842,27881,27919,28025,28038,28074,28315,28325,28427,28457,28485,28611,28612,28795,28841,28870,28877,28908,2897,29117,29160,29311,29488,29528,29547,29648,2966,29733,2979,29813,29822,29967,30069,30102,30125,30159,30166,30218,30491,30616,30688,30689,30699,30711,30807,30824,3084,3086,30867,30870,30910,30939,30978,31038,3105,31054,31103,31119,3114,3122,31225,31242,31288,31314,31317,31354,31390,31443,3146,31468,31473,31474,3149,31590,31595,31598,31614,31646,31664,31699,317,31730,31745,31770,31818,31886,31922,31934,31944,31960,31981,31997,3205,32058,32117,32142,32152,32234,32277,32329,3233,32399,32419,3242,32427,32469,32509,32546,32555,32584,32831,32839,32863,32889,32916,33015,33057,33148,33158,33187,33392,33397,33462,33485,33487],"n03127747":[1002,10078,10084,1019,1027,10284,10304,1031,10315,1036,1040,10451,10501,10510,10543,10567,1057,1060,10609,1061,10639,10648,1073,10757,10791,10864,10909,10926,10927,10938,10977,10981,10988,11072,11149,11151,11253,11270,1128,11362,11437,11497,11524,11554,11619,11646,11688,11752,11753,11771,1180,11800,11801,1187,11964,11990,12001,12105,12155,12167,12168,1221,1225,123,1233,12490,12576,12626,12628,12640,1269,1270,12705,12817,1284,12846,12904,12913,13004,13141,13191,13225,1327,1329,13292,13330,13343,13351,13370,13378,1339,13396,1340,13413,13436,13462,1349,13503,13511,13526,13639,1366,137,13702,13704,13767,13813,13871,13900,13915,13917,14040,14052,14078,1416,14164,14183,14197,1422,14331,14340,14342,14359,14404,14418,14427,1445,14456,14470,14472,14539,14611,14622,14634,14636,1467,147,14708,1479,14799,14818,14888,14957,1502,1507,15075,15197,15279,15332,15407,15413,1546,15483,15540,15543,1555,156,15630,15656,1577,15837,15883,15889,15894,15921,1604,16069,1612,16162,16195,1620,16223,16244,16257,16304,16376,16401,1641,16445,16454,1647,16506,16545,16570,16590,16629,16635,16657,16691,16701,16704,16772,16780,16787,16795,1681,1689,16995,17070,17130,17208,1726,17275,17314,17365,17520,1757,17665,17702,17788,17804,17869,1790,1800,18229,18281,18342,1836,1841,18414,1842,18441,18448,18456,18483,1849,1852,18614,18633,18661,18707,18717,18796,18933,18965,18984,19018,19022,19049,1906,1910,19109,19142,192,19230,1931,19320,19359,1936,19413,19530,1956,1963,19645,19684,1976,19877,19969,20039,2018,20254,20275,2033,2038,20449,20489,20496,2055,2056,20719,2104,2121,2122,2126,213,2140,21535,21646,22012,22124,22141,2265,2281,2327,2344,2351,2375,239,241,2414,2417,2436,2443,2450,2458,2479,2482,2533,2535,2537,2539,2547,2553,2564,2568,2576,2586,2593,2596,2631,2640,2650,2700,2768,277,2795,2824,2840,2855,2873,2888,2893,2916,2917,2921,2925,2950,2951,2955,2967,2986,2989,2994,3024,3033,3040,3053,3083,3110,3115,3131,3149,3157,3160,3161,3192,3193,3210,3250,3273,3279,3283,3301,3314,333,3336,3338,3348,3376,3381,3408,3414,3415,342,3421,3434,345,3453,3463,3479,3490,3495,3504,3518,3530,3545,3604,3659,3681,37,3704,3751,3770,3782,3797,3798,380,3801,3814,3826,3869,3883,3901,3912,3917,3927,3957,3968,3976,406,4062,410,4104,4134,4211,4229,4230,4243,4300,4324,433,4358,4361,4365,4382,443,4490,4501,4512,4527,4552,4554,4564,4575,4584,4591,4602,4604,4605,461,4624,4642,4646,4649,4654,4685,4694,4697,4702,4721,4739,4743,4751,4756,4764,4788,480,4834,4837,4856,4857,4859,4894,4899,4900,4912,4931,4936,4940,4951,4953,4955,5003,5005,5020,5022,5032,5057,5080,5091,5098,5139,5143,5177,5178,5196,5205,5227,5242,5257,5258,5266,5292,5299,5303,5305,5323,533,5344,5347,5352,5360,5365,5378,5398,5432,5500,5507,5527,5532],"n03124170":[10150,1025,10303,10401,10512,10593,10673,10734,10755,1079,1082,10828,10901,10917,1096,10982,1106,11136,11177,11182,114,11468,11557,11741,11811,11966,11993,12003,12087,12105,12181,12231,1225,12282,12301,12311,12324,12373,12423,12556,12557,1258,12627,12952,1317,13213,13237,1331,13332,13400,1341,13564,13616,13618,13623,13636,13734,13744,13746,13751,13755,13854,13870,13903,13910,13922,13927,13998,14045,14209,14254,14263,14337,14396,1453,14693,14995,150,15251,1552,1578,1598,1608,16155,16290,1687,1701,1702,1707,17362,18766,1883,1940,1942,1952,1990,19921,19952,2036,2123,2146,2175,2223,2268,2273,2325,2390,2410,2500,2504,2512,2566,2632,271,2812,2972,2982,2987,3017,3058,3093,3164,3165,3269,327,3332,3490,3495,3671,3673,3678,3738,3834,39,3902,3924,3948,4101,4223,4352,4416,4483,4517,4519,4597,4645,4994,5068,5090,512,5202,5219,5245,5262,5295,5340,5373,5383,5400,5421,5427,5452,5487,5494,5521,5576,5630,5654,5675,5701,5895,60,6047,6606,6694,6837,7040,7239,7488,7524,7620,7673,7702,7728,7730,7762,7811,7813,7816,7819,7822,7836,7881,7882,7885,7957,8051,8054,8077,8096,8165,8233,8346,8350,8375,8381,8440,8623,8834,892,8995,9053,9147,9176,927,9337,9388,9394,9429,9430,9524,9652,9680,9689,9703,973,9769,9817,9856,991],"n04259630":[10025,10032,10094,10161,10163,10177,10245,10247,10289,10362,1040,10450,10454,10533,10667,10744,10853,11001,1110,11158,11425,1170,1171,11860,11873,12039,12179,12246,12444,12536,12538,12584,12622,1271,12796,12909,13123,13242,13773,14079,1416,14340,14390,14394,144,14547,14617,14697,14912,1496,15009,15138,15236,15247,15438,15562,157,15750,15794,15938,1604,16045,16100,16123,16135,1615,16168,16194,16264,16341,16361,16446,16469,16626,16667,16795,16877,16917,16954,16972,17015,17146,17205,17295,17401,17441,17446,17456,17555,17608,17645,17685,17714,17793,178,17803,17854,18011,18058,18062,18199,18255,18283,18424,18469,18585,18602,19119,19218,19256,19717,19768,19804,1994,20113,2021,20278,2073,20995,2100,21095,21144,21163,2132,21421,21641,21717,2174,21750,21760,21807,21814,21834,21843,21874,21924,22005,22015,2204,22067,22075,22168,22190,22267,2227,22281,22303,22375,22593,22597,22712,22742,22918,22955,23047,23058,23588,23627,23768,23993,2459,24598,25038,25330,25390,25550,25574,256,25833,2585,2586,26142,26160,2622,26257,2629,26291,26311,26368,26588,26637,26735,27067,27098,2718,27200,27243,27246,27358,27398,27579,27636,2789,28203,2894,29525,3031,3070,31227,32351,338,3544,3553,3588,36590,3665,3698,3713,37320,3814,38448,38691,3953,3956,3985,4030,4100,4275,4364,4369,44,441,4499,4559,4664,4723,4785,4830,4870,4948,515,5167,5323,5617,579,585,5886,5904,6149,6320,6447,6474,6521,6572,6590,6673,6821,6840,6859,6945,7083,7238,7274,7309,7373,7475,7485,7533,7564,7652,7696,7708,7734,782,8037,8149,8241,8329,8526,869,8706,874,8798,883,8869,8964,8989,9001,906,916,9165,9316,9320,9325,9393,9403,9440,9447,9471,9556,9576,9622,9625,9669,9694,9721,9798,9906],"n03680355":[10143,10162,1017,10221,1030,10315,1036,10405,10462,10502,10525,10543,10556,10651,1067,10688,1071,10739,10759,10807,10823,10845,10860,10882,10923,110,1100,11006,11026,11038,1104,1111,1115,1124,11304,1131,11321,11330,11380,11397,11413,11421,11464,11466,11515,11526,11560,1157,1159,11602,1162,1170,1173,11770,11774,11777,11783,11814,1183,11884,11924,1201,12067,12099,12118,1212,1215,12150,12159,1220,1222,12316,12356,12358,12382,1241,1245,12504,1252,1253,12586,12600,12648,12717,1276,12796,12848,12943,12949,1295,130,1302,1308,13108,13162,1322,13252,13289,1335,13388,1341,13414,13487,1349,135,1357,13581,1362,13722,13745,13849,13858,1391,13927,13982,1402,1417,14235,14239,14289,1430,14349,14377,14478,1454,14686,14708,14776,14780,1479,14799,1484,14868,1504,15047,15054,1506,15070,15086,15210,1523,15257,15281,15298,15312,15326,15349,1543,1546,1569,1576,15817,15882,15927,1598,1621,1624,1635,16366,1642,1661,16842,16951,1696,17,17056,17172,17201,17203,17310,17318,1739,17457,17464,17484,17672,17781,1784,17897,18040,18169,1821,18234,18298,18356,18376,18410,1844,18505,1851,18891,18977,1901,19190,19218,19239,19478,1953,19863,19924,20094,20099,20181,2023,2025,20285,20481,20743,2085,2086,20888,20921,20969,21060,21190,2123,2126,21306,21312,2151,21682,21763,21988,2205,22110,22137,22148,22159,22282,2230,22334,2250,22644,2279,22836,2291,23054,23087,23111,2312,2318,23281,23495,23497,23533,23696,23910,23911,2393,2397,24007,2413,24135,24137,24159,2445,2453,24569,24613,2478,24787,2483,24831,25034,2506,25161,25242,25321,2548,2551,25548,2558,25601,25653,2567,2577,25780,25836,25863,25889,2590,2595,26077,2614,26175,26212,2622,2625,2640,2641,2657,2662,2669,2678,2689,2693,2702,2720,2737,2762,2778,2784,2812,2822,2826,284,2845,2846,2849,2868,2878,2910,2921,2927,2939,2963,3018,3020,3028,3046,3049,3103,3118,3133,3158,3191,3193,322,3287,3304,3313,3369,3386,34,3406,3458,3460,3462,3465,3498,3525,3595,3606,3611,3618,3641,3646,365,3669,3698,3744,377,3788,3809,3812,382,3861,3869,3870,3875,3879,3880,3915,3935,3940,3951,3961,3968,3974,3981,3991,4027,4034,4042,4058,4061,4088,4093,4111,412,4122,4126,4127,4137,4141,417,4170,4211,4215,4220,425,427,4280,4290,4319,4328,4375,4384,440,4421,4475,45,4513,452,4526,4556,4585,4593,4612,4622,4637,4649,4667,469,4699,4714,4727,473,4734,4747,4767,4773,4775,4776,4778,4823,4830,4832,484,4840,4843,4849,4851,4859,4871,4882,4906,4932,4964,4992,5003,5006,5017,5026,5050,5069,5084,5086,5114,514,5169,5182,5243,5247,53,531,5321,5322,5351,5361,5363,5369,5374,5382,5406,5407,5440,5467,5471,5472,548,5503,5506,5507,5509,5518,5579,5593,5637,5719,5734,586,5861,5897,601,6050,6064,610,6124,6135,6157,6159,620,639,6395,6399,6432,6479,654,670],"n03124043":[10079,1013,103,1035,10553,1058,1066,107,1075,1078,10967,111,1117,1127,11353,11440,1149,1159,11626,1168,117,1177,1188,1196,1200,1203,1207,121,1215,1229,12292,1232,1247,1248,1252,1259,1260,1299,13,130,1306,131,1311,1315,1319,13194,1320,1328,13494,1366,1377,1379,138,13832,13889,1395,1398,14,140,14046,1408,141,1417,1428,1432,1452,14565,1470,1476,1485,150,1532,1559,1570,1592,1597,1616,1626,1627,166,1690,1691,1693,1695,1703,1709,1713,1722,1727,1754,1770,1773,1799,180,1807,1818,1831,1834,1838,1845,1853,1865,188,18871,1922,1928,193,19300,1966,20311,20320,2043,2048,206,20684,2094,2105,2114,2116,21356,2152,2166,21739,21844,21860,2191,2207,221,2212,2233,225,2254,22856,2286,2291,22998,23079,2315,2332,23349,2340,23466,2352,23629,23752,2377,23936,23944,2400,24044,2407,24071,2438,24427,2447,245,246,24604,2470,2472,2475,2496,25277,25298,255,2550,256,25774,2589,2597,2598,2601,2624,26306,26376,2647,26493,2654,2664,2666,2667,2670,26730,2677,2698,2707,2709,2726,2729,2730,27427,2747,2753,2776,27849,2794,28130,2820,2833,28348,28402,2845,28480,2857,2861,2871,2886,2894,2898,29,2939,2941,2946,2968,297,299,300,30044,3020,3027,30292,3035,304,3041,3042,3045,305,3062,3064,30783,3081,3098,31170,315,3164,31687,317,318,3217,3251,3263,3264,3321,334,3344,3348,3362,3390,3409,3412,3414,342,3444,3447,3459,3464,3479,352,3542,3584,3593,3595,3608,3681,3703,371,3713,3726,3759,3805,3818,3841,3859,3940,3955,3993,4001,4011,4014,4021,4035,4040,4053,4060,4066,4069,4078,4084,4110,4131,4134,4149,4158,416,4163,4168,417,4178,4188,4191,4193,4194,42,4211,4219,4235,4242,4248,4254,4257,4259,4293,431,4353,4385,4388,440,4415,4432,4434,4441,4446,4448,4452,4458,4468,4477,4502,4505,4579,4673,4682,4686,4692,4702,4708,4759,4761,4767,477,4783,4793,4816,4851,4859,4864,4895,4903,4911,4923,4925,493,4934,4936,4940,4946,4948,4958,496,4967,4984,4991,5015,5032,5058,509,5090,5104,5112,5122,5136,5145,515,5153,5166,5178,5198,5201,5224,5229,5234,5235,5267,5314,5318,5329,5336,5339,5343,5371,5375,5377,538,5402,5409,5413,5424,5435,5438,544,5455,5477,5479,549,5498,5499,5501,5502,5503,5518,5569,5585,5589,5626,5637,564,5641,5643,569,5696,5711,5744,5753,5762,5806,5808,5814,5818,5846,5856,5865,5882,5883,589,5891,5901,5913,5934,5942,5945,5962,5963,5969,597,5996,6004,6017,602,6031,6042,6051,6063,6066,6082,6124,6131,6148,6188,6190,6194,6205,6207,6210,6214,6226,6227,6231,6236,625,6255,6259,6264,6269,6296,6301,6303,631,6311,6318,633,6338,6343,6349,6356,6358,6373,6375,6379,6382,6392,6399,6400,641,643,6430,644,6445,6446,645,6453],"n03838899":[10,1003,10111,10112,10144,10182,10223,10281,10328,10427,1059,10621,10668,10913,10914,10930,1117,11188,11431,11442,11485,11795,11829,1186,11878,12022,1216,1220,1227,12292,12312,12513,126,12822,1284,12926,13279,13399,1351,13656,13685,1383,13890,14099,14256,14373,14392,14424,1459,1500,15046,15091,1511,15337,15363,15371,15476,15511,15661,15690,15711,15764,15848,15855,1594,16089,16276,16314,16399,1642,16477,16540,16608,16858,16903,1694,16955,17015,17020,17078,1712,17202,17442,1745,17493,17537,17583,17983,18538,18870,19090,19426,19522,1955,19768,1978,19799,19897,19918,19949,20063,20146,2020,20254,20383,20609,20635,20658,21139,21289,21553,21683,217,2176,21823,21913,2204,22366,22539,2257,22632,2282,22942,22954,23021,23149,23213,23241,23434,23475,23627,2364,23823,23878,23890,23908,24223,24245,24366,24865,251,25220,25379,25677,26087,26096,26203,26502,26549,26589,26838,26866,26887,26927,26964,27021,27044,27095,27181,27234,27241,27256,27271,2742,27447,27503,27517,27522,27532,27643,27678,27747,27815,2783,27832,27889,27902,27947,27955,28028,28030,28033,28061,28136,28206,28244,28258,28485,28539,28563,28636,28655,28767,28777,28925,29020,29086,29213,29233,29329,2970,29719,29749,29885,29988,3,30058,30150,30196,30198,30212,30249,30251,30253,30288,3032,30370,30376,30394,30490,30550,30654,30678,30724,30739,30986,31206,31235,31236,31242,31329,3134,31372,31376,314,31473,31515,31520,31544,31579,31643,31659,31674,31698,31715,31829,31842,31875,31940,31941,31948,31983,31987,32004,32012,32031,32067,32105,32169,32177,32232,32237,32243,32255,32575,32582,32647,32648,32651,32800,32841,32864,32876,32965,32972,32976,32981,32991,33004,33035,33048,33102,33133,33213,33218,33243,33289,33290,33299,33315,33321,33330,33399,33408,33430,33457,33470,33562,33590,33603,33639,33651,33728,33745,33802,33817,3384,33848,33886,33914,340,34000,34024,34026,34425,34426,34432,34598,3469,34791,35032,35217,3527,35292,35513,35537,3565,35860,35867,35875,35902,36032,36271,36500,3656,366,37194,37569,37664,37804,37863,37941,38234,3840,39385,39667,39715,40007,40154,40221,40515,40885,40934,40980,41117,41410,41668,41699,41718,41744,42148,42170,42476,42566,43099,43272,43305,4350,43560,43672,43689,43833,43904,43907,44052,44159,4460,44701,4475,44912,44964,45030,45265,4527,45498,4556,45888,45935,45937,45972,46477,46501,46717,46843,47111,47175,48269,48543,48689,48734,48826,49082,49100,4913,49344,49709,50042,5006,50332,50390,51216,51309,5139,51492,51737,51739,51748,5205,52321,52381,52741,52763,52939,53316,53833,54303,54446,54531,54682,54815,54894,549,55037,55041,55583,55608,56017,56138,5630,5693,5735,57693,58099,5819,6218,6240,6263,6311,6407,6501,6669,6918,6927,694,7243,7251,7316,7438,7452,7505,7683,7723,7877,8045,805,8120,8550,8589,8598,8797,8823,8895,891,8982,9054,9128,9270,9300],"n03249569":[10072,10145,10176,10224,1030,10319,10711,10881,11019,11024,11068,11069,11071,11149,11255,1130,11493,11583,11727,11745,11776,1190,11932,12008,12101,12129,12241,12252,12262,12274,12284,12417,12449,12465,12665,12788,12811,12878,12907,12914,12976,13027,13220,13294,13393,13446,13454,13487,13584,1361,13664,13708,13799,1384,1404,14054,14115,14143,14167,1445,14461,14525,14534,14565,14569,14604,14753,1514,15270,15473,15593,15758,15813,15845,15994,160,16023,16093,16136,16170,16203,16214,16260,16304,16387,16460,16483,16521,16550,16712,16753,16760,1677,16807,16846,16942,16973,17054,17095,17174,17216,17313,17341,1735,17352,17392,17395,17404,17437,17439,17447,17452,17470,17506,17598,17606,17639,17679,17758,17835,17863,17932,17973,17994,18013,18156,18297,18457,18546,18656,18658,18669,18677,18796,18884,19098,19113,19118,19154,19187,19266,19303,19455,19465,19482,19490,19518,19602,19800,1992,19987,20057,20079,20123,20180,20181,20182,20304,20314,20374,20436,20509,20559,20591,20820,20875,20897,20973,20982,20995,2101,21060,21066,21215,21225,21320,21349,21368,21411,21517,21594,2172,21803,21946,21961,22044,22082,22135,22163,22274,22311,22327,22477,22485,22501,22669,22749,22840,22848,22861,22953,22956,23024,23059,23060,23070,23110,23220,2330,23367,23863,24093,2412,24134,24170,24268,24324,24613,24935,25014,25089,25280,25330,25479,25482,25517,2552,25541,25575,25626,25967,25976,26155,26328,26366,26373,26504,26513,26539,26609,26695,26818,26958,26990,27088,27139,27390,27608,27645,27746,27763,27772,27782,27793,27906,27971,2800,28078,2809,28097,28194,2821,28215,28245,28248,2832,28482,28525,28585,28593,2877,28797,2882,29201,29524,29605,2971,29775,29863,30018,30053,30120,30121,30233,30244,30280,30293,30316,30451,30494,30618,3066,30684,30739,3081,30914,31014,31033,31106,31109,31137,31172,31185,312,31271,31272,31275,31311,3132,31348,31375,31507,31603,31625,31643,31745,31763,31794,31822,31836,3190,3194,3221,32276,32454,33103,33200,33436,33617,33814,33823,33885,33999,3400,34017,34162,3448,34607,34752,34830,34833,34868,34879,35025,35030,35043,35050,35052,35162,3519,35228,35249,35310,35333,35362,35415,35430,35567,35589,35612,35637,35657,35714,35774,35812,35820,35840,35888,35932,35935,3596,35961,35971,36030,36059,36133,36162,36200,36234,36361,36434,36445,36477,36519,36603,36622,36668,36771,36807,36819,36853,36854,37051,37056,37062,37099,37143,37201,37374,37383,37773,3783,37850,37870,37899,3790,37903,3791,37946,37965,38281,38451,38641,38688,38744,38789,38838,38922,390,39002,39070,39072,3910,39187,39217,39264,39369,39451,39681,39763,3996,40000,40138,40273,4037,4045,4049,40579,40580,40732,40812,40955,41969,42071,42109,42120,42134,4218,42221,42276,42285,42312,42456,42488,42499,42507,42571,42631,42732,42765,42889,42913,42920,4294,42959,43080,43201,43251,43279,43350,43504,43515,43573,43583,43987,4430,44331,44585,44586,44675,44800,45216,45310,45408,45434,45468,45516,45554,45682,45696,45731,45743,45806,45811,45846,45860,45944,45986,46000,46081],"n04074963":[10005,10029,10107,10117,10129,10135,1015,10191,10247,10273,10282,10321,10395,10406,10424,1046,10468,10474,10509,1052,10557,10653,10655,10675,10704,10742,1075,10841,10947,10951,10968,10995,11012,11040,11081,11119,11143,11160,11163,11213,11226,11244,11289,11290,11339,11358,11419,11424,11434,11442,11445,11454,11500,11506,11519,11522,11535,11554,11559,1156,11575,11582,11590,1166,11668,11676,11704,11709,1177,1179,11798,11802,11807,11834,11845,11850,11862,11864,11875,11883,11895,11910,11947,11975,11976,1200,12015,12041,12050,12059,12073,12077,12090,12101,12130,12166,1225,12291,12303,12362,12451,12458,1247,1252,12534,12537,12568,12612,12643,12698,12720,12752,12763,1277,12787,12818,12819,1282,12849,12871,12893,12896,1290,12924,12958,12981,13005,1307,13088,13135,13216,13225,13252,13274,1345,13461,13484,13565,13635,13685,13692,13708,13718,1381,13855,13890,13938,13977,13991,14035,14041,1408,14085,14089,14104,14117,14125,14153,14158,1423,14250,14274,14307,14321,14331,14361,1438,14409,14450,14454,14490,1453,1454,1456,14573,14577,14593,1466,14676,14705,14724,14860,14864,14905,1491,14966,14979,14982,150,15043,15045,15058,15078,15089,15105,1512,15147,15152,15167,15170,15171,15189,15208,15212,15349,15412,15421,15444,1558,1567,15765,15774,15839,15876,15881,159,15909,15965,15970,16,16025,16049,16073,16078,16092,1611,16130,16151,16234,1624,16240,16285,16303,16314,16372,16394,16406,16431,1652,16551,16602,16616,16623,16674,1668,16692,1675,16779,16790,16836,16842,16845,16855,16858,16868,16876,16915,16924,16956,1696,16968,17141,17162,17185,1720,17241,17286,17333,17397,17418,17422,17424,17460,17466,17475,17537,17562,17592,17619,17625,17647,17717,1772,17720,17744,17801,1783,17883,17983,17989,1807,18107,18117,18173,18194,18202,18203,18236,18275,18300,18322,18345,18352,18383,18430,18461,1847,18507,18541,18566,18590,18697,18730,18741,18744,18786,18793,18833,18861,18883,18907,18942,18951,19043,19081,19099,19114,19162,19216,1923,19234,1925,19295,1933,1939,19396,19398,19428,19430,19436,19438,19473,19483,19493,19545,1955,19576,19578,19622,19637,1964,19650,1967,19673,19677,19710,1973,19742,19748,19798,19851,19858,19859,19870,19884,19895,19965,20017,20088,20093,20098,20133,20183,20213,20226,2025,20276,20286,20290,20314,20315,20316,20332,20341,20342,20407,20449,20476,20480,20513,2052,20520,20550,20561,20582,20627,20628,20631,20634,20684,20698,20716,20724,20727,20735,20745,208,20802,20808,2081,20829,20881,20888,20907,20909,20936,20981,20984,2102,21025,21040,21046,21060,21077,21086,2109,21112,21142,21180,21181,21195,21198,21213,21214,21234,21278,21280,21291,21338,21359,21371,21372,21403,21427,21431,21463,21464,21477,21484,21513,21517,21529,21533,21542,21548,21557,2158,21590,2161,2163,21644,21674,21685,21707,21730,21732,21735,21742,2175,21757,21836,22101,22166,224,22506,22560,22584,2264,22676,22688,22723,22748,22840,22901,22906,22916,22930,23,23076,23078,2312,23136,2319,23226,2325,23251,2329,23314,2338,2343],"n02676566":[10012,10017,1002,10062,10075,10100,10102,10114,10171,10299,1044,10467,1049,1056,10750,108,10830,10832,1087,10900,10902,10977,11034,11052,11067,11110,11113,11123,11129,11140,11184,11208,11215,1122,11239,11293,11301,11334,1136,11441,11513,11573,1158,11580,11643,118,11818,11897,11957,12007,12075,12103,12121,12164,12199,12229,12244,12344,1236,12360,12398,1240,12438,12503,1256,12565,12570,12573,12575,12643,12662,12691,12754,12763,12820,12827,12864,12910,12963,130,13036,1304,13067,13083,13126,13212,13267,13455,13473,13619,1365,13663,1393,1418,1434,1441,14507,15152,15190,15218,15296,1555,1587,1606,164,1645,1646,165,1651,167,1690,1691,17,1707,1728,1736,1757,178,1825,183,1835,1843,1855,1866,1882,1956,1964,1973,202,2046,2066,218,2187,219,22,2230,2237,2252,2256,2258,2263,2325,2330,2373,2380,242,2454,2460,2471,2480,2554,259,2631,2684,2696,2769,2778,2779,2803,281,2825,2876,2899,2913,2952,2954,2967,2970,2980,3004,306,3069,307,3085,3101,3109,3115,3120,3125,3127,3159,3161,3206,328,3314,3324,3325,3339,3340,3382,3385,3386,3394,3401,3402,341,3424,343,3440,3461,3471,3482,3492,3500,3523,3527,3528,3540,3541,3629,3650,3660,367,3750,3753,3767,380,3854,3876,3889,3892,3916,3920,3957,3977,3978,399,402,4057,4058,4059,406,4064,4074,4075,4095,4130,4134,4137,4160,4166,4171,4178,4208,4212,4236,4240,4241,4251,4252,4254,4305,4317,4343,4366,4391,4394,4402,4407,4415,4419,4425,4426,4441,4454,4462,4469,449,4493,4507,4530,4532,4537,4543,4573,4584,4595,4602,4604,4605,461,4621,4623,4632,4648,4668,467,4679,4697,4699,4706,4759,4789,4793,4795,4812,4823,4825,4839,4853,4877,4883,4893,4916,4928,4936,4946,5000,5001,5012,5109,511,5168,523,5255,5256,529,5293,5355,5356,5363,5364,5367,5372,5373,5380,5400,5408,5411,5412,5416,5421,5427,5430,5437,5438,5448,5450,5453,5454,5457,5460,5461,5464,5468,5476,5480,5489,5507,5508,5515,5518,5522,5524,5534,5535,5545,5559,556,5591,5601,5610,5637,5641,5645,5649,5684,5689,5713,5735,5742,5773,5776,5830,5860,5861,5871,5943,5966,602,6024,6030,6150,616,6178,6196,6200,6202,6234,6245,6253,6260,6265,6268,6269,6289,6292,6293,6302,6303,6304,6306,6319,6320,6326,6329,6335,6341,6343,6351,6354,6355,6363,6370,6372,6377,6378,6384,6390,6392,6402,6405,6414,6430,6435,6437,6466,6467,6469,6479,6489,6493,650,6518,6532,654,6544,6549,6554,6557,6559,6560,6563,6571,6575,6582,6583,6588,6589,6590,6604,6615,6625,6633,6636,6637,6644,6646,665,6658,6659,6660,6661,6672,6673,6674,6677,6682,6687,6703,6704,6705,6713,6737,6738,6744,6746,6750,6753,6762,6763,6764,6766,6770,6772,6778,6796,6799,6801,6839,684,6842,6843,6855,6857,6858,6865,6871,6875,6881],"n03272010":[10127,10170,10237,10363,10399,10424,10441,10443,10457,10510,106,10612,1067,10690,107,10795,10806,10815,10841,10848,10946,10973,11016,1109,11110,1114,11264,11276,11297,11343,11356,11378,11419,11443,11451,11498,115,11502,11505,11513,11538,11598,116,1165,11675,11740,11743,11764,11777,11814,11857,11879,11890,11925,11953,120,1203,12051,12069,12110,12151,12196,12204,1221,1242,12468,1259,1264,12662,1268,12924,1296,12967,1301,1304,13242,1328,1334,1336,1342,1345,1346,1377,13804,13813,13834,13914,13963,13968,1399,140,14010,1405,14073,1411,14119,14144,1415,142,1422,14226,1425,1432,14364,1442,1445,14490,14495,1462,1464,14690,14701,14736,1487,1496,1503,1507,15078,15107,1511,1523,1526,1529,1531,1536,1550,1551,1552,1553,1574,1576,15764,1579,15795,1582,15857,159,15907,15922,1594,1595,1608,1609,1616,1618,1630,1640,1643,1654,1656,1666,1676,16905,1699,17033,1708,1710,1711,1714,1726,1727,1739,1745,1747,175,1750,176,1760,1762,1763,17764,17768,1781,17811,1783,17873,1807,1852,1872,1881,189,1894,1924,1938,1939,1943,1953,1962,1973,1976,1988,1992,2001,2002,2018,2024,2033,2036,2042,2046,2058,2060,2070,2089,2114,2125,2126,2134,2137,2142,2150,2152,2159,2162,2168,2195,2197,2199,2210,2218,2223,2230,2232,2234,2238,2246,2256,2268,2278,2289,2294,2301,2312,2314,2316,232,2322,2323,2332,234,2372,2385,2387,2391,2411,2414,2420,2438,2442,2444,2459,2463,2467,2475,2481,2490,2529,2536,2559,2583,2618,263,2695,2772,278,2790,287,2880,2919,2922,2925,2929,2966,2999,3002,3022,3092,3136,3139,317,3181,3190,3191,3221,3227,3235,3239,3247,3251,3276,3281,3293,3294,330,3312,3313,3324,3338,3339,3343,3346,3353,3364,3371,3390,3393,34,3400,3414,3432,3452,3459,347,3471,3474,3475,3480,3482,3514,3521,3532,3538,3547,3552,3597,36,362,3621,364,3652,3669,3699,3715,3721,3726,3727,3728,373,3732,3743,3752,3763,3769,3770,3785,3790,3791,3793,3801,3805,3811,382,3832,386,3861,3870,3874,389,3896,3910,392,3929,3975,398,3981,3989,3993,3995,4005,4010,4016,4024,4053,4054,4061,4062,4075,4088,4092,4093,4099,412,4132,4135,4148,4199,4217,4218,4221,4229,4248,4252,4264,4287,431,433,4333,4340,4348,4361,4370,4372,4395,4441,4443,446,447,4472,4478,4509,4547,4553,4554,4572,4579,4587,459,4598,460,4607,4611,4616,4618,4621,4643,4648,4660,4669,4673,4693,4702,4703,4713,4726,4728,474,4751,4766,4768,4769,477,4774,4776,4778,4800,4806,4818,4821,4829,4830,4832,4836,4837,4845,4858,4861,4864,4865,4872,4876,4886,49,4900,4901,4902,491,4939,4950,4953,4966,5019,504,5103,5150,5152,5177,519,52,525,5253,5257,526,527,534,5362,5373,5381,5412,5421,5424,5425,5427,543,5437,544,549,5510,5514,552,5525],"n04152593":[10032,10033,1011,10111,10136,10240,10293,10382,1039,10409,10413,1052,10559,10572,10684,10707,10729,10778,10860,10874,10988,11016,11054,11079,11094,11120,11193,1122,11226,11247,11444,11495,1150,11516,11537,11572,11659,11730,11747,11804,11848,11876,11898,11901,11903,11945,12111,12136,1214,12184,12204,12249,12276,12299,12324,1244,12450,12470,12539,12547,1258,12581,12607,12653,12665,127,12727,12759,12771,1290,12912,12948,12952,12961,12975,12992,12996,13020,13026,13031,13082,13116,13122,13127,13168,13170,13181,13203,13206,1324,13244,13319,13328,13347,13402,13430,135,13511,13576,13603,13640,13665,13698,1375,13774,13802,13815,13819,13826,13834,13922,13962,13975,13979,13988,13993,14043,14058,14115,14228,14328,14343,14420,14440,14444,14474,145,14525,14537,14547,14553,14567,14576,14590,14638,14650,14665,14733,1474,14741,14776,14811,14818,14828,1483,14844,1485,14850,14890,1493,15007,15045,1507,15090,15129,15140,15212,15220,15235,15291,1533,15359,1543,15479,15517,15522,15533,1554,15547,15551,15569,1558,15696,15712,15748,15752,15767,15810,15879,15891,15954,16019,16096,16142,16189,16200,16264,1629,16323,16328,16329,16344,16363,16367,16370,16381,16391,16393,16416,16457,1646,16466,16478,16488,16515,16592,16627,16646,16690,16714,16718,1679,16819,16822,16846,16856,16866,16931,16966,16989,16990,16993,1706,17111,1712,1716,17181,17206,17233,17258,17329,17460,17469,17494,17512,17535,17629,17647,17767,17789,178,1782,17967,18034,18116,182,18217,18219,18233,18331,18361,18442,18451,185,18503,18540,18552,18557,18567,18570,18577,18585,18593,18611,18627,1863,18633,18643,18656,18674,18689,18698,18706,18708,1875,18781,18911,18921,18923,190,19066,19096,19194,19493,19553,19555,19604,1962,19716,19771,19779,19889,19923,1995,1997,20054,20092,2018,20281,2037,20371,20393,20412,20439,2051,20542,20554,2063,20696,20787,20874,20960,20962,21046,21134,21199,21202,21232,21480,2152,2153,21607,21732,2174,21772,2193,21966,22077,22166,22231,2226,22299,22306,22414,22421,22451,22460,22559,22609,22613,22642,22652,22675,22742,2283,23051,23055,2320,23232,23324,23354,23492,23503,23504,23528,23531,23540,23560,23627,23765,23836,23842,23888,23892,23952,24004,24028,24045,24069,24127,24223,24235,24260,24319,2441,24465,24508,24510,24566,24567,2457,24576,24651,2466,24697,2479,24839,24856,24901,25052,25066,25071,25131,25202,25203,25334,25368,2560,25630,25673,2568,25707,25837,26118,26146,26280,26390,2641,26479,26847,26887,26950,26980,26991,2712,2718,27273,27511,27530,27579,27590,2761,27710,2777,27847,27876,27895,27926,2793,27975,27986,28060,28105,28288,28312,2833,2841,28468,2858,28607,28626,28675,28760,288,28862,2889,28913,29083,29091,29097,29342,29410,29477,29489,29558,29593,29607,29609,2969,29774,29818,29859,2986,29990,3003,30034,30138,30172,30233,30380,30465,30487,30577,30630,3070,30743,30766,3085,30864,30909,3097,31026,31103,3116,31225,31304,3134,31376,3140,31429,31451,31503,31636,3164,3165,31822,31846,31938,31988,32010],"n04590129":[1001,10036,1006,1014,10201,10378,10412,1049,10499,10522,10550,10565,10597,10680,1069,10691,10697,10726,10734,10735,10736,10746,10756,10783,10862,10864,10881,10920,10940,11028,11034,11098,11107,1112,1113,11155,11157,1116,11167,1118,11265,11362,11388,1143,11484,11510,11535,1155,1159,1162,1167,11673,11706,1173,11820,11844,11845,1186,1194,11991,1215,1221,1223,12234,12238,1227,12321,12349,1239,12475,12548,12596,12649,1272,12733,12762,12774,12799,12862,12877,129,1290,12966,13042,13080,13289,1330,13365,13375,13399,13429,13434,13452,13501,13521,13577,13767,13799,13840,13918,13993,140,1407,14074,14136,14154,142,14261,1429,14372,14415,14465,14489,14611,1480,14803,14815,1494,14945,14978,14995,14997,1502,15112,15194,15209,1534,15342,1536,15442,15483,15533,1559,15622,15675,15800,15806,15822,15827,15830,15852,15867,15904,1592,1595,16084,16104,1613,16131,16167,16175,16218,1623,16231,16242,16331,16350,16357,16386,1640,16410,16427,16547,16600,1663,16683,1671,16759,16760,16763,16766,16788,16793,1680,16801,16815,16819,16839,16873,16886,1695,16974,1698,16998,17044,1706,17067,17086,17134,17145,17147,17174,1720,17237,1728,17300,17309,17311,17335,17340,17347,17387,17388,17392,17425,17431,17445,17464,17487,1749,17521,17526,17533,17606,1764,17648,17654,17661,17665,1767,17680,17681,17685,17692,17725,17729,17749,1778,1781,17833,1785,17897,1790,17925,1796,17996,18016,18024,18027,18046,18070,1812,18120,1816,18176,18209,18220,18333,18346,18351,18381,18415,18437,18448,18495,18506,18575,18637,1866,1869,18732,18751,188,1885,189,18927,18950,19100,19114,19117,19213,19295,19428,19499,1955,1968,19722,19727,19790,19795,19866,1993,1994,19977,1999,20,20009,20081,2009,20119,2012,20164,20228,20243,20259,20267,20274,2028,2030,20346,20384,2039,20396,20438,20487,20597,2060,20641,20667,20691,20719,20758,20763,20808,20811,2082,2086,2089,20897,20900,20919,20925,2094,20960,20983,2102,21054,21094,21115,2112,21124,21137,21140,21151,21174,21176,21190,21299,21318,21362,21377,21379,21396,21408,21418,21436,21466,21467,21479,21481,21492,21494,21511,21523,21542,21559,21585,21601,21608,21613,21618,21621,21631,21636,21642,21662,21689,21697,21736,21763,21804,21811,21827,21838,21839,21841,21858,21890,21891,21892,21908,21916,21938,2195,21963,21968,21976,21980,21998,22042,22048,22049,2206,22064,22068,22078,22110,22128,22135,22149,22164,22175,22194,22205,22207,22210,2223,22238,22241,22252,22263,22277,22281,22292,22294,22295,22307,22389,22407,22408,2243,22436,22476,22520,22524,22565,22597,22604,22609,22641,22645,22685,22728,22785,2280,2281,22812,2283,22843,22854,22879,22883,22891,22892,22943,2298,2302,23022,23023,23033,23058,23085,23131,23152,23180,23181,23247,23323,23324,23326,23336,23375,23379,23389,23441,23469,235,23505,23525,23533,23548,2355,23593,23600,23620,2365,23665,23719,23721,2373,23750,2376,23779,23894,23931,23966,23972,24008,24026,24046,24048,24073,24116,24117,24171,24183,24195,24231,24260,24300],"n04418357":[10012,10109,10121,10136,10249,1026,10293,1030,10333,10404,10416,10475,10487,1052,10530,10559,1056,10714,10779,10813,1082,10924,10949,10955,10989,1101,11025,11042,11115,11146,11151,11304,11361,11371,11391,11409,11425,11432,11485,1151,11526,11529,1156,11591,11635,11672,11674,11779,11850,11863,11962,1198,11980,11981,11998,12073,12088,1209,121,12219,12231,12233,12270,12288,12292,12317,12353,12397,12430,12439,12458,12508,12513,12572,12581,12635,12672,12703,12708,12728,12854,1289,12932,1300,13018,13035,13041,13043,13140,13203,13208,13364,13378,13381,13513,13527,13597,13614,1368,1372,13785,13793,1380,13920,140,1402,14107,14160,14214,14229,1426,14562,14607,14610,14622,14707,14791,14792,148,14906,14942,14988,15132,1529,1530,15350,1539,15509,15519,1552,15521,15532,15553,15577,15601,15635,15663,1576,15830,15884,1589,15897,1592,1597,15980,16041,16091,16096,161,16112,16163,1617,16203,16387,16470,16500,16508,16558,16589,16592,16632,16656,16666,16760,16761,16780,16809,1683,16839,16881,1693,16944,171,17118,17176,17216,1723,17243,17261,17312,17320,17341,17401,1741,1744,17476,17506,17518,1752,17556,1757,17594,17807,1782,17851,17862,17940,17967,18001,18018,1802,1810,18152,18160,18174,18215,18235,18284,18301,184,18402,18419,18438,18449,185,18538,18551,1861,18740,1876,18828,18848,1892,1897,18982,18995,19010,19022,1904,19106,19144,19178,19237,19239,1927,19390,19447,1947,19540,19642,19651,19660,19698,19704,19709,19772,19824,19852,19865,19866,19947,2007,20124,20149,20153,20241,20248,20313,2032,20326,20345,20379,2046,20521,20522,2053,20674,2073,2085,20863,20920,20978,20984,20997,2105,21069,21070,2143,21456,2146,21478,2153,21539,21633,21639,21661,2170,21787,21822,21826,21890,2190,21967,21978,21982,21997,22007,22021,22056,22097,221,22281,22357,22462,22465,2248,22486,22593,22654,22677,22691,22767,22927,2293,2295,22963,22967,23052,23053,2317,232,23266,23268,2340,23464,23471,2350,23516,23531,23567,23581,2366,23675,2372,23738,23757,2387,2393,24,24284,24370,24434,24446,2445,24513,24638,2471,24752,2476,24841,2486,2517,25255,2531,25363,25364,2545,2550,2551,25554,25661,25667,25699,25708,25739,25743,25877,2590,25910,25962,25982,26000,26036,26078,26340,2642,26423,26639,26695,2673,26765,26841,26867,26950,2714,27198,2728,2754,2758,2759,2763,27705,27761,27827,27830,27869,27934,27939,27940,28021,28058,28105,28157,28164,28166,28205,28432,2844,28465,2849,28531,28532,2856,28571,28670,28702,28750,28793,2893,28931,28971,28983,2900,29018,29038,2904,29191,2925,29371,2940,29431,29463,2955,29560,29576,29729,29804,29874,29914,2997,30043,3005,30144,30258,30285,3034,3044,30546,3056,30581,30634,30646,3070,30732,30860,30938,31130,31292,3136,3145,31484,3150,31543,3156,3161,3165,31708,31858,3188,31936,3209,32097,32176,32187,3225,32472,32492,32639,3273,32731,3278,3316,3318,332,3342,3371,3385,33970,34,34096,34097,34211,3437,34444,3459,3467,34764,3488,3518,35201]}}

discovery/prop_specificity.json

@@ -0,0 +1,710 @@
+{
+  "provenance": {
+    "generator": null,
+    "note": "discovery sweep not committed; no producer in the repo"
+  },
+  "n_prop_images": 8479,
+  "ranked_candidates": [
+    {
+      "dim": 11,
+      "prop_mean": 1.7091748714447021,
+      "person_pos_mean": 1.089888095855713,
+      "person_neg_mean": 1.1654655933380127,
+      "prop_vs_neg": 0.5437092781066895,
+      "person_vs_neg": -0.0755774974822998,
+      "score": 0.6192867755889893
+    },
+    {
+      "dim": 697,
+      "prop_mean": 1.63211190700531,
+      "person_pos_mean": 1.0918049812316895,
+      "person_neg_mean": 1.0371267795562744,
+      "prop_vs_neg": 0.5949851274490356,
+      "person_vs_neg": 0.05467820167541504,
+      "score": 0.5403069257736206
+    },
+    {
+      "dim": 572,
+      "prop_mean": 1.4398308992385864,
+      "person_pos_mean": 0.9548083543777466,
+      "person_neg_mean": 0.8750605583190918,
+      "prop_vs_neg": 0.5647703409194946,
+      "person_vs_neg": 0.07974779605865479,
+      "score": 0.48502254486083984
+    },
+    {
+      "dim": 671,
+      "prop_mean": 1.5082179307937622,
+      "person_pos_mean": 1.0776139497756958,
+      "person_neg_mean": 1.0892691612243652,
+      "prop_vs_neg": 0.418948769569397,
+      "person_vs_neg": -0.011655211448669434,
+      "score": 0.4306039810180664
+    },
+    {
+      "dim": 51,
+      "prop_mean": 1.2916672229766846,
+      "person_pos_mean": 0.8612672090530396,
+      "person_neg_mean": 0.6743829846382141,
+      "prop_vs_neg": 0.6172842383384705,
+      "person_vs_neg": 0.18688422441482544,
+      "score": 0.430400013923645
+    },
+    {
+      "dim": 186,
+      "prop_mean": 1.783549189567566,
+      "person_pos_mean": 1.3718806505203247,
+      "person_neg_mean": 1.2572942972183228,
+      "prop_vs_neg": 0.5262548923492432,
+      "person_vs_neg": 0.11458635330200195,
+      "score": 0.4116685390472412
+    },
+    {
+      "dim": 752,
+      "prop_mean": 1.4307368993759155,
+      "person_pos_mean": 1.0203551054000854,
+      "person_neg_mean": 0.9466467499732971,
+      "prop_vs_neg": 0.4840901494026184,
+      "person_vs_neg": 0.07370835542678833,
+      "score": 0.4103817939758301
+    },
+    {
+      "dim": 90,
+      "prop_mean": 1.4134135246276855,
+      "person_pos_mean": 1.027899980545044,
+      "person_neg_mean": 1.2588216066360474,
+      "prop_vs_neg": 0.15459191799163818,
+      "person_vs_neg": -0.23092162609100342,
+      "score": 0.3855135440826416
+    },
+    {
+      "dim": 161,
+      "prop_mean": 1.110310673713684,
+      "person_pos_mean": 0.7282975316047668,
+      "person_neg_mean": 0.8111143708229065,
+      "prop_vs_neg": 0.2991963028907776,
+      "person_vs_neg": -0.08281683921813965,
+      "score": 0.38201314210891724
+    },
+    {
+      "dim": 310,
+      "prop_mean": 1.6827064752578735,
+      "person_pos_mean": 1.306183934211731,
+      "person_neg_mean": 1.5448638200759888,
+      "prop_vs_neg": 0.13784265518188477,
+      "person_vs_neg": -0.2386798858642578,
+      "score": 0.3765225410461426
+    },
+    {
+      "dim": 88,
+      "prop_mean": 1.7690833806991577,
+      "person_pos_mean": 1.3999791145324707,
+      "person_neg_mean": 1.0576374530792236,
+      "prop_vs_neg": 0.7114459276199341,
+      "person_vs_neg": 0.34234166145324707,
+      "score": 0.369104266166687
+    },
+    {
+      "dim": 189,
+      "prop_mean": 1.2615772485733032,
+      "person_pos_mean": 0.893500030040741,
+      "person_neg_mean": 1.0122331380844116,
+      "prop_vs_neg": 0.2493441104888916,
+      "person_vs_neg": -0.11873310804367065,
+      "score": 0.36807721853256226
+    },
+    {
+      "dim": 613,
+      "prop_mean": 1.854291558265686,
+      "person_pos_mean": 1.4975982904434204,
+      "person_neg_mean": 1.73020339012146,
+      "prop_vs_neg": 0.12408816814422607,
+      "person_vs_neg": -0.23260509967803955,
+      "score": 0.3566932678222656
+    },
+    {
+      "dim": 201,
+      "prop_mean": 1.4382827281951904,
+      "person_pos_mean": 1.0972189903259277,
+      "person_neg_mean": 1.0087069272994995,
+      "prop_vs_neg": 0.4295758008956909,
+      "person_vs_neg": 0.08851206302642822,
+      "score": 0.3410637378692627
+    },
+    {
+      "dim": 360,
+      "prop_mean": 1.5004557371139526,
+      "person_pos_mean": 1.1636990308761597,
+      "person_neg_mean": 1.24490487575531,
+      "prop_vs_neg": 0.2555508613586426,
+      "person_vs_neg": -0.08120584487915039,
+      "score": 0.33675670623779297
+    },
+    {
+      "dim": 623,
+      "prop_mean": 1.1354831457138062,
+      "person_pos_mean": 0.8059989809989929,
+      "person_neg_mean": 0.7583788633346558,
+      "prop_vs_neg": 0.3771042823791504,
+      "person_vs_neg": 0.04762011766433716,
+      "score": 0.32948416471481323
+    },
+    {
+      "dim": 688,
+      "prop_mean": 1.4130481481552124,
+      "person_pos_mean": 1.0897259712219238,
+      "person_neg_mean": 1.1911897659301758,
+      "prop_vs_neg": 0.22185838222503662,
+      "person_vs_neg": -0.10146379470825195,
+      "score": 0.3233221769332886
+    },
+    {
+      "dim": 578,
+      "prop_mean": 1.6479562520980835,
+      "person_pos_mean": 1.3283374309539795,
+      "person_neg_mean": 1.4025310277938843,
+      "prop_vs_neg": 0.24542522430419922,
+      "person_vs_neg": -0.07419359683990479,
+      "score": 0.319618821144104
+    },
+    {
+      "dim": 81,
+      "prop_mean": 1.904716968536377,
+      "person_pos_mean": 1.597719430923462,
+      "person_neg_mean": 1.7867015600204468,
+      "prop_vs_neg": 0.11801540851593018,
+      "person_vs_neg": -0.18898212909698486,
+      "score": 0.30699753761291504
+    },
+    {
+      "dim": 692,
+      "prop_mean": 1.381159782409668,
+      "person_pos_mean": 1.0755085945129395,
+      "person_neg_mean": 1.1753791570663452,
+      "prop_vs_neg": 0.20578062534332275,
+      "person_vs_neg": -0.09987056255340576,
+      "score": 0.3056511878967285
+    },
+    {
+      "dim": 638,
+      "prop_mean": 1.2797389030456543,
+      "person_pos_mean": 0.9781198501586914,
+      "person_neg_mean": 1.0837996006011963,
+      "prop_vs_neg": 0.195939302444458,
+      "person_vs_neg": -0.10567975044250488,
+      "score": 0.3016190528869629
+    },
+    {
+      "dim": 522,
+      "prop_mean": 1.194052815437317,
+      "person_pos_mean": 0.8986038565635681,
+      "person_neg_mean": 0.8541845679283142,
+      "prop_vs_neg": 0.3398682475090027,
+      "person_vs_neg": 0.044419288635253906,
+      "score": 0.2954489588737488
+    },
+    {
+      "dim": 257,
+      "prop_mean": 1.8521565198898315,
+      "person_pos_mean": 1.5771883726119995,
+      "person_neg_mean": 1.6870157718658447,
+      "prop_vs_neg": 0.16514074802398682,
+      "person_vs_neg": -0.10982739925384521,
+      "score": 0.27496814727783203
+    },
+    {
+      "dim": 340,
+      "prop_mean": 0.9343926906585693,
+      "person_pos_mean": 0.6695823669433594,
+      "person_neg_mean": 0.6695160269737244,
+      "prop_vs_neg": 0.26487666368484497,
+      "person_vs_neg": 6.633996963500977e-05,
+      "score": 0.26481032371520996
+    },
+    {
+      "dim": 308,
+      "prop_mean": 1.525191068649292,
+      "person_pos_mean": 1.2669845819473267,
+      "person_neg_mean": 1.1947391033172607,
+      "prop_vs_neg": 0.33045196533203125,
+      "person_vs_neg": 0.07224547863006592,
+      "score": 0.25820648670196533
+    },
+    {
+      "dim": 479,
+      "prop_mean": 1.2297685146331787,
+      "person_pos_mean": 0.9748978018760681,
+      "person_neg_mean": 0.9749308824539185,
+      "prop_vs_neg": 0.25483763217926025,
+      "person_vs_neg": -3.30805778503418e-05,
+      "score": 0.2548707127571106
+    },
+    {
+      "dim": 299,
+      "prop_mean": 1.3217650651931763,
+      "person_pos_mean": 1.0688191652297974,
+      "person_neg_mean": 1.1240233182907104,
+      "prop_vs_neg": 0.19774174690246582,
+      "person_vs_neg": -0.055204153060913086,
+      "score": 0.2529458999633789
+    },
+    {
+      "dim": 440,
+      "prop_mean": 1.1131365299224854,
+      "person_pos_mean": 0.8602599501609802,
+      "person_neg_mean": 0.8018559217453003,
+      "prop_vs_neg": 0.31128060817718506,
+      "person_vs_neg": 0.05840402841567993,
+      "score": 0.2528765797615051
+    },
+    {
+      "dim": 458,
+      "prop_mean": 1.2792733907699585,
+      "person_pos_mean": 1.029525637626648,
+      "person_neg_mean": 0.9404508471488953,
+      "prop_vs_neg": 0.33882254362106323,
+      "person_vs_neg": 0.08907479047775269,
+      "score": 0.24974775314331055
+    },
+    {
+      "dim": 767,
+      "prop_mean": 1.4785064458847046,
+      "person_pos_mean": 1.2433205842971802,
+      "person_neg_mean": 1.2814769744873047,
+      "prop_vs_neg": 0.1970294713973999,
+      "person_vs_neg": -0.03815639019012451,
+      "score": 0.23518586158752441
+    },
+    {
+      "dim": 713,
+      "prop_mean": 2.0065953731536865,
+      "person_pos_mean": 1.7764008045196533,
+      "person_neg_mean": 1.8709570169448853,
+      "prop_vs_neg": 0.13563835620880127,
+      "person_vs_neg": -0.09455621242523193,
+      "score": 0.2301945686340332
+    },
+    {
+      "dim": 554,
+      "prop_mean": 1.3773629665374756,
+      "person_pos_mean": 1.1489109992980957,
+      "person_neg_mean": 1.0569530725479126,
+      "prop_vs_neg": 0.320409893989563,
+      "person_vs_neg": 0.0919579267501831,
+      "score": 0.22845196723937988
+    },
+    {
+      "dim": 0,
+      "prop_mean": 1.518669605255127,
+      "person_pos_mean": 1.292944312095642,
+      "person_neg_mean": 1.2706265449523926,
+      "prop_vs_neg": 0.24804306030273438,
+      "person_vs_neg": 0.02231776714324951,
+      "score": 0.22572529315948486
+    },
+    {
+      "dim": 351,
+      "prop_mean": 1.5037388801574707,
+      "person_pos_mean": 1.2783546447753906,
+      "person_neg_mean": 1.0354632139205933,
+      "prop_vs_neg": 0.46827566623687744,
+      "person_vs_neg": 0.24289143085479736,
+      "score": 0.22538423538208008
+    },
+    {
+      "dim": 266,
+      "prop_mean": 3.2978885173797607,
+      "person_pos_mean": 3.0799922943115234,
+      "person_neg_mean": 3.1888484954833984,
+      "prop_vs_neg": 0.1090400218963623,
+      "person_vs_neg": -0.108856201171875,
+      "score": 0.2178962230682373
+    },
+    {
+      "dim": 469,
+      "prop_mean": 1.2845133543014526,
+      "person_pos_mean": 1.0693851709365845,
+      "person_neg_mean": 1.0766862630844116,
+      "prop_vs_neg": 0.20782709121704102,
+      "person_vs_neg": -0.0073010921478271484,
+      "score": 0.21512818336486816
+    },
+    {
+      "dim": 250,
+      "prop_mean": 1.1550997495651245,
+      "person_pos_mean": 0.9470953941345215,
+      "person_neg_mean": 1.0209672451019287,
+      "prop_vs_neg": 0.1341325044631958,
+      "person_vs_neg": -0.07387185096740723,
+      "score": 0.20800435543060303
+    },
+    {
+      "dim": 684,
+      "prop_mean": 1.217105507850647,
+      "person_pos_mean": 1.0223654508590698,
+      "person_neg_mean": 0.9934371113777161,
+      "prop_vs_neg": 0.2236683964729309,
+      "person_vs_neg": 0.02892833948135376,
+      "score": 0.19474005699157715
+    },
+    {
+      "dim": 604,
+      "prop_mean": 1.4056569337844849,
+      "person_pos_mean": 1.2120150327682495,
+      "person_neg_mean": 1.3198471069335938,
+      "prop_vs_neg": 0.08580982685089111,
+      "person_vs_neg": -0.10783207416534424,
+      "score": 0.19364190101623535
+    },
+    {
+      "dim": 251,
+      "prop_mean": 1.238474726676941,
+      "person_pos_mean": 1.0456016063690186,
+      "person_neg_mean": 1.1859287023544312,
+      "prop_vs_neg": 0.052546024322509766,
+      "person_vs_neg": -0.1403270959854126,
+      "score": 0.19287312030792236
+    },
+    {
+      "dim": 275,
+      "prop_mean": 1.1440684795379639,
+      "person_pos_mean": 0.9552448391914368,
+      "person_neg_mean": 1.0024899244308472,
+      "prop_vs_neg": 0.1415785551071167,
+      "person_vs_neg": -0.0472450852394104,
+      "score": 0.1888236403465271
+    },
+    {
+      "dim": 236,
+      "prop_mean": 1.3713657855987549,
+      "person_pos_mean": 1.1866233348846436,
+      "person_neg_mean": 1.346700668334961,
+      "prop_vs_neg": 0.024665117263793945,
+      "person_vs_neg": -0.16007733345031738,
+      "score": 0.18474245071411133
+    },
+    {
+      "dim": 110,
+      "prop_mean": 1.3540358543395996,
+      "person_pos_mean": 1.1696140766143799,
+      "person_neg_mean": 1.1514066457748413,
+      "prop_vs_neg": 0.2026292085647583,
+      "person_vs_neg": 0.018207430839538574,
+      "score": 0.18442177772521973
+    },
+    {
+      "dim": 660,
+      "prop_mean": 1.294521689414978,
+      "person_pos_mean": 1.110160231590271,
+      "person_neg_mean": 1.258522391319275,
+      "prop_vs_neg": 0.035999298095703125,
+      "person_vs_neg": -0.1483621597290039,
+      "score": 0.18436145782470703
+    },
+    {
+      "dim": 141,
+      "prop_mean": 1.2327960729599,
+      "person_pos_mean": 1.0510427951812744,
+      "person_neg_mean": 1.1455810070037842,
+      "prop_vs_neg": 0.08721506595611572,
+      "person_vs_neg": -0.09453821182250977,
+      "score": 0.1817532777786255
+    },
+    {
+      "dim": 436,
+      "prop_mean": 0.7790431380271912,
+      "person_pos_mean": 0.6001676321029663,
+      "person_neg_mean": 0.7653905153274536,
+      "prop_vs_neg": 0.013652622699737549,
+      "person_vs_neg": -0.1652228832244873,
+      "score": 0.17887550592422485
+    },
+    {
+      "dim": 732,
+      "prop_mean": 2.213838815689087,
+      "person_pos_mean": 2.035112142562866,
+      "person_neg_mean": 2.0301244258880615,
+      "prop_vs_neg": 0.1837143898010254,
+      "person_vs_neg": 0.0049877166748046875,
+      "score": 0.1787266731262207
+    },
+    {
+      "dim": 160,
+      "prop_mean": 1.1959549188613892,
+      "person_pos_mean": 1.02139151096344,
+      "person_neg_mean": 0.985637366771698,
+      "prop_vs_neg": 0.21031755208969116,
+      "person_vs_neg": 0.03575414419174194,
+      "score": 0.17456340789794922
+    },
+    {
+      "dim": 543,
+      "prop_mean": 1.6499507427215576,
+      "person_pos_mean": 1.4781776666641235,
+      "person_neg_mean": 1.5063472986221313,
+      "prop_vs_neg": 0.14360344409942627,
+      "person_vs_neg": -0.028169631958007812,
+      "score": 0.17177307605743408
+    },
+    {
+      "dim": 27,
+      "prop_mean": 1.3894929885864258,
+      "person_pos_mean": 1.2205332517623901,
+      "person_neg_mean": 1.2239311933517456,
+      "prop_vs_neg": 0.16556179523468018,
+      "person_vs_neg": -0.0033979415893554688,
+      "score": 0.16895973682403564
+    }
+  ],
+  "sweeps": [
+    {
+      "extra_neg_k": 0,
+      "F1": 0.884742021560669,
+      "threshold": 24.868803024291992,
+      "precision": 0.8963522911071777,
+      "recall": 0.8734287023544312,
+      "prop_false_positive_rate": 0.0593230314552784,
+      "added_dims": []
+    },
+    {
+      "extra_neg_k": 5,
+      "F1": 0.8799648880958557,
+      "threshold": 19.580781936645508,
+      "precision": 0.8911111354827881,
+      "recall": 0.8690940737724304,
+      "prop_false_positive_rate": 0.04576011374592781,
+      "added_dims": [
+        11,
+        697,
+        572,
+        671,
+        51
+      ]
+    },
+    {
+      "extra_neg_k": 10,
+      "F1": 0.8703535795211792,
+      "threshold": 15.480006217956543,
+      "precision": 0.9121140241622925,
+      "recall": 0.8322497010231018,
+      "prop_false_positive_rate": 0.033730391412973404,
+      "added_dims": [
+        11,
+        697,
+        572,
+        671,
+        51,
+        186,
+        752,
+        90,
+        161,
+        310
+      ]
+    },
+    {
+      "extra_neg_k": 15,
+      "F1": 0.8526602983474731,
+      "threshold": 10.094175338745117,
+      "precision": 0.8967001438140869,
+      "recall": 0.8127438426017761,
+      "prop_false_positive_rate": 0.027243778109550476,
+      "added_dims": [
+        11,
+        697,
+        572,
+        671,
+        51,
+        186,
+        752,
+        90,
+        161,
+        310,
+        88,
+        189,
+        613,
+        201,
+        360
+      ]
+    },
+    {
+      "extra_neg_k": 20,
+      "F1": 0.8446601629257202,
+      "threshold": 2.4011502265930176,
+      "precision": 0.860224723815918,
+      "recall": 0.8296489119529724,
+      "prop_false_positive_rate": 0.031135747209191322,
+      "added_dims": [
+        11,
+        697,
+        572,
+        671,
+        51,
+        186,
+        752,
+        90,
+        161,
+        310,
+        88,
+        189,
+        613,
+        201,
+        360,
+        623,
+        688,
+        578,
+        81,
+        692
+      ]
+    },
+    {
+      "extra_neg_k": 30,
+      "F1": 0.8187528252601624,
+      "threshold": -6.868839740753174,
+      "precision": 0.8484426140785217,
+      "recall": 0.7910706400871277,
+      "prop_false_positive_rate": 0.023115932941436768,
+      "added_dims": [
+        11,
+        697,
+        572,
+        671,
+        51,
+        186,
+        752,
+        90,
+        161,
+        310,
+        88,
+        189,
+        613,
+        201,
+        360,
+        623,
+        688,
+        578,
+        81,
+        692,
+        638,
+        522,
+        257,
+        340,
+        308,
+        479,
+        299,
+        440,
+        458,
+        767
+      ]
+    },
+    {
+      "extra_neg_k": 40,
+      "F1": 0.7954637408256531,
+      "threshold": -25.408130645751953,
+      "precision": 0.7464842200279236,
+      "recall": 0.8513220548629761,
+      "prop_false_positive_rate": 0.043047528713941574,
+      "added_dims": [
+        11,
+        697,
+        572,
+        671,
+        51,
+        186,
+        752,
+        90,
+        161,
+        310,
+        88,
+        189,
+        613,
+        201,
+        360,
+        623,
+        688,
+        578,
+        81,
+        692,
+        638,
+        522,
+        257,
+        340,
+        308,
+        479,
+        299,
+        440,
+        458,
+        767,
+        713,
+        554,
+        0,
+        351,
+        266,
+        469,
+        250,
+        684,
+        604,
+        251
+      ]
+    },
+    {
+      "extra_neg_k": 50,
+      "F1": 0.7818812131881714,
+      "threshold": -36.89189910888672,
+      "precision": 0.7386276125907898,
+      "recall": 0.8305158019065857,
+      "prop_false_positive_rate": 0.041278451681137085,
+      "added_dims": [
+        11,
+        697,
+        572,
+        671,
+        51,
+        186,
+        752,
+        90,
+        161,
+        310,
+        88,
+        189,
+        613,
+        201,
+        360,
+        623,
+        688,
+        578,
+        81,
+        692,
+        638,
+        522,
+        257,
+        340,
+        308,
+        479,
+        299,
+        440,
+        458,
+        767,
+        713,
+        554,
+        0,
+        351,
+        266,
+        469,
+        250,
+        684,
+        604,
+        251,
+        275,
+        236,
+        110,
+        660,
+        141,
+        436,
+        732,
+        160,
+        543,
+        27
+      ]
+    }
+  ]
+}

discovery/variant_leaderboard.json

@@ -0,0 +1,232 @@
+{
+  "provenance": {
+    "generator": null,
+    "note": "discovery sweep not committed; no producer in the repo"
+  },
+  "results": [
+    {
+      "name": "ref: full 768 ridge",
+      "params": 769,
+      "F1": 0.9598035216331482,
+      "precision": 0.9898664355278015,
+      "recall": 0.9315127730369568,
+      "threshold": null
+    },
+    {
+      "name": "ref: K=92 ridge (cojoint top-92 + bias)",
+      "params": 93,
+      "F1": 0.9463722109794617,
+      "precision": 0.9854528307914734,
+      "recall": 0.9102730751037598,
+      "threshold": null
+    },
+    {
+      "name": "E: ternary weights top-50 pos vs top-50 neg, threshold",
+      "params": 1,
+      "F1": 0.8933987617492676,
+      "precision": 0.9200735092163086,
+      "recall": 0.8682271242141724,
+      "threshold": 31.819643020629883
+    },
+    {
+      "name": "C: threshold(sum top-20 pos \u2212 sum top-20 neg)",
+      "params": 1,
+      "F1": 0.8808632493019104,
+      "precision": 0.8952551484107971,
+      "recall": 0.8669267296791077,
+      "threshold": 24.8664608001709
+    },
+    {
+      "name": "E: ternary weights top-20 pos vs top-20 neg, threshold",
+      "params": 1,
+      "F1": 0.8808632493019104,
+      "precision": 0.8952551484107971,
+      "recall": 0.8669267296791077,
+      "threshold": 24.86646270751953
+    },
+    {
+      "name": "C: threshold(sum top-10 pos \u2212 sum top-10 neg)",
+      "params": 1,
+      "F1": 0.8801606893539429,
+      "precision": 0.9070836901664734,
+      "recall": 0.8547897934913635,
+      "threshold": 22.383634567260742
+    },
+    {
+      "name": "E: ternary weights top-10 pos vs top-10 neg, threshold",
+      "params": 1,
+      "F1": 0.8801606893539429,
+      "precision": 0.9070836901664734,
+      "recall": 0.8547897934913635,
+      "threshold": 22.383630752563477
+    },
+    {
+      "name": "B: threshold(sum top-2 pos dims)",
+      "params": 1,
+      "F1": 0.8780821561813354,
+      "precision": 0.9276410937309265,
+      "recall": 0.8335500359535217,
+      "threshold": 14.303534507751465
+    },
+    {
+      "name": "B: threshold(sum top-20 pos dims)",
+      "params": 1,
+      "F1": 0.8683924674987793,
+      "precision": 0.8716157078742981,
+      "recall": 0.8651928901672363,
+      "threshold": 62.11921310424805
+    },
+    {
+      "name": "C: threshold(sum top-5 pos \u2212 sum top-5 neg)",
+      "params": 1,
+      "F1": 0.8637353181838989,
+      "precision": 0.867512047290802,
+      "recall": 0.8599913120269775,
+      "threshold": 27.896242141723633
+    },
+    {
+      "name": "B: threshold(sum top-10 pos dims)",
+      "params": 1,
+      "F1": 0.8574432134628296,
+      "precision": 0.8325847387313843,
+      "recall": 0.883831799030304,
+      "threshold": 45.166908264160156
+    },
+    {
+      "name": "A: threshold(dim48)",
+      "params": 1,
+      "F1": 0.8451337814331055,
+      "precision": 0.8776844143867493,
+      "recall": 0.8149111270904541,
+      "threshold": 6.3439040184021
+    },
+    {
+      "name": "ref: K=1 ridge (dim48 + bias)",
+      "params": 2,
+      "F1": 0.8285356163978577,
+      "precision": 0.7985524535179138,
+      "recall": 0.8608582615852356,
+      "threshold": null
+    },
+    {
+      "name": "B: threshold(sum top-5 pos dims)",
+      "params": 1,
+      "F1": 0.8214052319526672,
+      "precision": 0.824454128742218,
+      "recall": 0.8183788657188416,
+      "threshold": 37.6262092590332
+    },
+    {
+      "name": "C: threshold(sum top-3 pos \u2212 sum top-3 neg)",
+      "params": 1,
+      "F1": 0.8199912905693054,
+      "precision": 0.8185744881629944,
+      "recall": 0.8214130997657776,
+      "threshold": 18.052114486694336
+    },
+    {
+      "name": "B: threshold(sum top-3 pos dims)",
+      "params": 1,
+      "F1": 0.7914334535598755,
+      "precision": 0.7131432294845581,
+      "recall": 0.8890333771705627,
+      "threshold": 23.4901123046875
+    },
+    {
+      "name": "D: threshold(max top-3 pos \u2212 max top-3 neg)",
+      "params": 1,
+      "F1": 0.7337717413902283,
+      "precision": 0.6004415154457092,
+      "recall": 0.9432163238525391,
+      "threshold": 4.771557331085205
+    },
+    {
+      "name": "D: threshold(max top-5 pos \u2212 max top-5 neg)",
+      "params": 1,
+      "F1": 0.7142618894577026,
+      "precision": 0.5805314779281616,
+      "recall": 0.9280450940132141,
+      "threshold": 6.046311378479004
+    },
+    {
+      "name": "D: threshold(max top-10 pos \u2212 max top-10 neg)",
+      "params": 1,
+      "F1": 0.7102322578430176,
+      "precision": 0.5886545181274414,
+      "recall": 0.8951018452644348,
+      "threshold": 4.326292991638184
+    },
+    {
+      "name": "D: threshold(max top-20 pos \u2212 max top-20 neg)",
+      "params": 1,
+      "F1": 0.7102322578430176,
+      "precision": 0.5886545181274414,
+      "recall": 0.8951018452644348,
+      "threshold": 4.326292991638184
+    }
+  ],
+  "top_pos_dims_30": [
+    48,
+    525,
+    475,
+    645,
+    273,
+    292,
+    158,
+    510,
+    506,
+    337,
+    8,
+    309,
+    267,
+    217,
+    79,
+    13,
+    657,
+    207,
+    722,
+    311,
+    566,
+    278,
+    25,
+    627,
+    511,
+    332,
+    654,
+    719,
+    593,
+    305
+  ],
+  "top_neg_dims_30": [
+    642,
+    224,
+    113,
+    565,
+    49,
+    637,
+    45,
+    520,
+    219,
+    290,
+    529,
+    617,
+    269,
+    745,
+    576,
+    701,
+    105,
+    694,
+    82,
+    283,
+    574,
+    310,
+    613,
+    90,
+    92,
+    650,
+    36,
+    53,
+    396,
+    17
+  ]
+}

eval.json

@@ -0,0 +1,20 @@
+{
+  "provenance": {
+    "generator": "verify.py",
+    "classifier": "classifier.json",
+    "classifier_sha256": "19b70ff5e4e2977b80bac7e8915acd70dfe42691ae7fa55470c7f1a2580d5d0c",
+    "pool": "VAL5000",
+    "split": "val2017",
+    "n_images": 5000,
+    "positive_rate": 0.539,
+    "task": "image-level person presence (binary)",
+    "protocol": "live backbone forward at 768 px, no feature caching",
+    "selection": "the first 5000 val2017 image ids in sorted order, which is the whole split"
+  },
+  "metrics": {
+    "F1": 0.8886,
+    "precision": 0.9011,
+    "recall": 0.8763,
+    "threshold": 25.284494400024414
+  }
+}

eval_tight_fpr.json

@@ -0,0 +1,21 @@
+{
+  "provenance": {
+    "generator": null,
+    "classifier": "classifier_tight_fpr.json",
+    "classifier_sha256": "21da0c971c21e3504de458f97c396df23c8cbc97ad3813435703c8e9b89f66ef",
+    "pool": null,
+    "task": "image-level person presence (binary)",
+    "measured_by": "stage_0/discovery/prop_specificity.json, extra_neg_k=15"
+  },
+  "metrics": {
+    "F1": 0.8527,
+    "precision": 0.8967,
+    "recall": 0.8127,
+    "threshold": 10.094175338745117
+  },
+  "prop_false_positive_rate": 0.0272,
+  "baseline": {
+    "F1": 0.8847,
+    "prop_false_positive_rate": 0.0593
+  }
+}

head.py

@@ -0,0 +1,81 @@
+"""The classifier as a fused Linear with fixed ternary weights and one free bias.
+
+    model = FusedClassifier.from_hub()
+    score, present = model(image_tensor)
+
+Constructed without a backbone the module still exposes `head`, the same
+decision applied to an already-pooled vector.
+"""
+import argparse
+import json
+import sys
+from pathlib import Path
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))  # repo root, for `common`
+from common import BACKBONE, pool  # noqa: E402
+
+HERE = Path(__file__).resolve().parent
+
+
+class FusedClassifier(nn.Module):
+    """Backbone -> 40-dim slice -> ternary linear head -> binary decision.
+
+    `retained_dims` indexes the 768-D pooled vector; `retained_weight` is +1 on
+    the person-positive positions and -1 on the person-negative ones. The
+    threshold is the only free parameter.
+    """
+
+    def __init__(self, backbone, pos_dims, neg_dims, threshold):
+        super().__init__()
+        self.backbone = backbone
+        retained = list(pos_dims) + list(neg_dims)
+        self.register_buffer('retained_dims', torch.tensor(retained, dtype=torch.long))
+        w = torch.zeros(1, len(retained))
+        w[0, :len(pos_dims)] = 1.0
+        w[0, len(pos_dims):] = -1.0
+        self.register_buffer('retained_weight', w)
+        self.threshold = nn.Parameter(torch.tensor(float(threshold)))
+
+    def head(self, pooled):
+        """(..., 768) pooled vector -> (score, present), no backbone involved."""
+        retained = pooled.index_select(-1, self.retained_dims)
+        score = F.linear(retained, self.retained_weight).squeeze(-1)
+        return score, score > self.threshold
+
+    @torch.inference_mode()
+    def forward(self, x):
+        """x: (B, 3, 768, 768) normalized. Returns (score (B,), present (B,))."""
+        if self.backbone is None:
+            raise RuntimeError('constructed without a backbone; use .head(pooled)')
+        dev = 'cuda' if x.is_cuda else 'cpu'
+        with torch.autocast(dev, dtype=torch.bfloat16):
+            out = self.backbone.forward_features(x)
+        return self.head(pool(out['x_norm_patchtokens'].float()))
+
+    @classmethod
+    def from_config(cls, backbone=None, classifier_json=None):
+        c = json.loads(Path(classifier_json or HERE / 'classifier.json').read_text())
+        return cls(backbone, c['pos_dims'], c['neg_dims'], c['threshold'])
+
+    @classmethod
+    def from_hub(cls, repo_or_path=None, classifier_json=None):
+        from common.models import load_backbone
+        return cls.from_config(load_backbone(repo_or_path or BACKBONE), classifier_json)
+
+
+if __name__ == '__main__':
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument('--classifier', type=Path, default=HERE / 'classifier.json')
+    args = ap.parse_args()
+    m = FusedClassifier.from_hub(classifier_json=args.classifier).eval()
+    n_all = sum(p.numel() for p in m.parameters())
+    n_backbone = sum(p.numel() for p in m.backbone.parameters())
+    print(f'total params:    {n_all:,}')
+    print(f'backbone params: {n_backbone:,}')
+    print(f'head params:     {n_all - n_backbone} '
+          f'(one learnable threshold; weights are fixed buffers)')
+    print(f'retained dims:   {m.retained_dims.numel()}')

infer.py

@@ -0,0 +1,85 @@
+"""Load a classifier variant and score images for person presence.
+
+    from infer import PersonDetector
+    det = PersonDetector.load('baseline')
+    score, present = det.predict('image.jpg')
+
+`score` is positive for person scenes; `present` is `score > threshold`.
+
+Variants
+    baseline    the classifier
+    tight_fpr   the same, with 15 extra prop-suppressing negative dims
+"""
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Tuple
+
+import torch
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))  # repo root, for `common`
+from common import BACKBONE, RES, backbone_pooled, device, load_image, score  # noqa: E402
+from common.models import load_backbone  # noqa: E402
+
+HERE = Path(__file__).resolve().parent
+CONFIGS = {'baseline': 'classifier.json', 'tight_fpr': 'classifier_tight_fpr.json'}
+
+
+class PersonDetector:
+    def __init__(self, forward_fn, pos_dims, neg_dims, threshold, dev):
+        self._forward = forward_fn
+        self._dev = dev
+        self._pos = torch.tensor(pos_dims, dtype=torch.long, device=dev)
+        self._neg = torch.tensor(neg_dims, dtype=torch.long, device=dev)
+        self._thr = float(threshold)
+
+    @property
+    def threshold(self) -> float:
+        return self._thr
+
+    @torch.inference_mode()
+    def predict(self, image) -> Tuple[float, bool]:
+        pooled = self._forward(load_image(image, RES, self._dev))
+        s = float(score(pooled, self._pos, self._neg))
+        return s, s > self._thr
+
+    @classmethod
+    def load(cls, variant: str = 'baseline', backbone_repo: str = BACKBONE,
+             root=None) -> 'PersonDetector':
+        root = Path(root) if root else HERE
+        if variant not in CONFIGS:
+            raise ValueError(f'unknown variant {variant!r}; expected one of '
+                             f'{sorted(CONFIGS)}')
+        dev = device()
+        backbone = load_backbone(backbone_repo).to(dev)
+        c = cls._classifier(root / CONFIGS[variant])
+        return cls(lambda x: backbone_pooled(backbone, x)[0],
+                   c['pos_dims'], c['neg_dims'], c['threshold'], dev)
+
+    @staticmethod
+    def _classifier(path) -> dict:
+        """Read a classifier config, cross-checking the safetensors beside it."""
+        path = Path(path)
+        c = json.loads(path.read_text())
+        weights = path.with_suffix('.safetensors')
+        if weights.exists():
+            from safetensors.torch import load_file
+            t = load_file(str(weights))
+            for key in ('pos_dims', 'neg_dims'):
+                if t[key].tolist() != c[key]:
+                    raise ValueError(f'{weights.name} disagrees with {path.name} on {key}')
+            if abs(float(t['threshold'][0]) - float(c['threshold'])) > 1e-4:
+                raise ValueError(f'{weights.name} disagrees with {path.name} on threshold')
+        return c
+
+
+if __name__ == '__main__':
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument('variant', choices=sorted(CONFIGS))
+    ap.add_argument('images', nargs='+')
+    args = ap.parse_args()
+    det = PersonDetector.load(args.variant)
+    for path in args.images:
+        s, present = det.predict(path)
+        print(f'{path}  score={s:+.3f}  threshold={det.threshold:+.3f}  person={present}')

per_dim_thresholds.json

@@ -0,0 +1,348 @@
+{
+  "provenance": {
+    "generator": "calibrate.py",
+    "classifier": "classifier.json",
+    "classifier_sha256": "19b70ff5e4e2977b80bac7e8915acd70dfe42691ae7fa55470c7f1a2580d5d0c",
+    "pool": "BALANCED_VAL",
+    "split": "val2017",
+    "n_images": 4614,
+    "positive_rate": 0.5,
+    "seed": 0,
+    "selection": "val2017 subsampled without replacement to equal person-positive and person-negative counts"
+  },
+  "quant_scale": 8,
+  "per_dim_thresholds": [
+    {
+      "dim_index_in_40": 0,
+      "dim_global": 48,
+      "is_pos": true,
+      "threshold": 6.572150230407715,
+      "threshold_int8": 53,
+      "per_dim_F1": 0.8464522361755371
+    },
+    {
+      "dim_index_in_40": 1,
+      "dim_global": 525,
+      "is_pos": true,
+      "threshold": 7.047104358673096,
+      "threshold_int8": 56,
+      "per_dim_F1": 0.7466137409210205
+    },
+    {
+      "dim_index_in_40": 2,
+      "dim_global": 475,
+      "is_pos": true,
+      "threshold": 3.269585132598877,
+      "threshold_int8": 26,
+      "per_dim_F1": 0.6843164563179016
+    },
+    {
+      "dim_index_in_40": 3,
+      "dim_global": 645,
+      "is_pos": true,
+      "threshold": 7.4769134521484375,
+      "threshold_int8": 60,
+      "per_dim_F1": 0.7112371325492859
+    },
+    {
+      "dim_index_in_40": 4,
+      "dim_global": 273,
+      "is_pos": true,
+      "threshold": 2.0735650062561035,
+      "threshold_int8": 17,
+      "per_dim_F1": 0.7335397005081177
+    },
+    {
+      "dim_index_in_40": 5,
+      "dim_global": 292,
+      "is_pos": true,
+      "threshold": 1.5521039962768555,
+      "threshold_int8": 12,
+      "per_dim_F1": 0.732986569404602
+    },
+    {
+      "dim_index_in_40": 6,
+      "dim_global": 158,
+      "is_pos": true,
+      "threshold": 2.054447889328003,
+      "threshold_int8": 16,
+      "per_dim_F1": 0.6832557320594788
+    },
+    {
+      "dim_index_in_40": 7,
+      "dim_global": 510,
+      "is_pos": true,
+      "threshold": 0.10592363774776459,
+      "threshold_int8": 1,
+      "per_dim_F1": 0.6806007027626038
+    },
+    {
+      "dim_index_in_40": 8,
+      "dim_global": 506,
+      "is_pos": true,
+      "threshold": 0.642810583114624,
+      "threshold_int8": 5,
+      "per_dim_F1": 0.7115705609321594
+    },
+    {
+      "dim_index_in_40": 9,
+      "dim_global": 337,
+      "is_pos": true,
+      "threshold": 1.3417854309082031,
+      "threshold_int8": 11,
+      "per_dim_F1": 0.705616295337677
+    },
+    {
+      "dim_index_in_40": 10,
+      "dim_global": 8,
+      "is_pos": true,
+      "threshold": 0.520650327205658,
+      "threshold_int8": 4,
+      "per_dim_F1": 0.6678624749183655
+    },
+    {
+      "dim_index_in_40": 11,
+      "dim_global": 309,
+      "is_pos": true,
+      "threshold": 0.44822290539741516,
+      "threshold_int8": 4,
+      "per_dim_F1": 0.6864839196205139
+    },
+    {
+      "dim_index_in_40": 12,
+      "dim_global": 267,
+      "is_pos": true,
+      "threshold": 0.7230344414710999,
+      "threshold_int8": 6,
+      "per_dim_F1": 0.7057974338531494
+    },
+    {
+      "dim_index_in_40": 13,
+      "dim_global": 217,
+      "is_pos": true,
+      "threshold": 1.1072767972946167,
+      "threshold_int8": 9,
+      "per_dim_F1": 0.6852783560752869
+    },
+    {
+      "dim_index_in_40": 14,
+      "dim_global": 79,
+      "is_pos": true,
+      "threshold": 0.9621400237083435,
+      "threshold_int8": 8,
+      "per_dim_F1": 0.6922308206558228
+    },
+    {
+      "dim_index_in_40": 15,
+      "dim_global": 13,
+      "is_pos": true,
+      "threshold": 2.015596389770508,
+      "threshold_int8": 16,
+      "per_dim_F1": 0.6755585670471191
+    },
+    {
+      "dim_index_in_40": 16,
+      "dim_global": 657,
+      "is_pos": true,
+      "threshold": 0.7083938121795654,
+      "threshold_int8": 6,
+      "per_dim_F1": 0.6905635595321655
+    },
+    {
+      "dim_index_in_40": 17,
+      "dim_global": 207,
+      "is_pos": true,
+      "threshold": 0.7881279587745667,
+      "threshold_int8": 6,
+      "per_dim_F1": 0.7052351236343384
+    },
+    {
+      "dim_index_in_40": 18,
+      "dim_global": 722,
+      "is_pos": true,
+      "threshold": 0.895519495010376,
+      "threshold_int8": 7,
+      "per_dim_F1": 0.6906405091285706
+    },
+    {
+      "dim_index_in_40": 19,
+      "dim_global": 311,
+      "is_pos": true,
+      "threshold": 1.051217794418335,
+      "threshold_int8": 8,
+      "per_dim_F1": 0.6888962388038635
+    },
+    {
+      "dim_index_in_40": 20,
+      "dim_global": 642,
+      "is_pos": false,
+      "threshold": 4.502034664154053,
+      "threshold_int8": 36,
+      "per_dim_F1": 0.6846261024475098
+    },
+    {
+      "dim_index_in_40": 21,
+      "dim_global": 224,
+      "is_pos": false,
+      "threshold": 5.5922465324401855,
+      "threshold_int8": 45,
+      "per_dim_F1": 0.6726456880569458
+    },
+    {
+      "dim_index_in_40": 22,
+      "dim_global": 113,
+      "is_pos": false,
+      "threshold": 2.338114023208618,
+      "threshold_int8": 19,
+      "per_dim_F1": 0.6799814701080322
+    },
+    {
+      "dim_index_in_40": 23,
+      "dim_global": 565,
+      "is_pos": false,
+      "threshold": 1.811521291732788,
+      "threshold_int8": 14,
+      "per_dim_F1": 0.6747174263000488
+    },
+    {
+      "dim_index_in_40": 24,
+      "dim_global": 49,
+      "is_pos": false,
+      "threshold": 1.7180224657058716,
+      "threshold_int8": 14,
+      "per_dim_F1": 0.680044949054718
+    },
+    {
+      "dim_index_in_40": 25,
+      "dim_global": 637,
+      "is_pos": false,
+      "threshold": 7.861576080322266,
+      "threshold_int8": 63,
+      "per_dim_F1": 0.6734788417816162
+    },
+    {
+      "dim_index_in_40": 26,
+      "dim_global": 45,
+      "is_pos": false,
+      "threshold": 2.251237630844116,
+      "threshold_int8": 18,
+      "per_dim_F1": 0.6706920266151428
+    },
+    {
+      "dim_index_in_40": 27,
+      "dim_global": 520,
+      "is_pos": false,
+      "threshold": 6.079483985900879,
+      "threshold_int8": 49,
+      "per_dim_F1": 0.675870954990387
+    },
+    {
+      "dim_index_in_40": 28,
+      "dim_global": 219,
+      "is_pos": false,
+      "threshold": 2.141653060913086,
+      "threshold_int8": 17,
+      "per_dim_F1": 0.668889582157135
+    },
+    {
+      "dim_index_in_40": 29,
+      "dim_global": 290,
+      "is_pos": false,
+      "threshold": 2.1265642642974854,
+      "threshold_int8": 17,
+      "per_dim_F1": 0.6621823906898499
+    },
+    {
+      "dim_index_in_40": 30,
+      "dim_global": 529,
+      "is_pos": false,
+      "threshold": 2.183765411376953,
+      "threshold_int8": 17,
+      "per_dim_F1": 0.669143795967102
+    },
+    {
+      "dim_index_in_40": 31,
+      "dim_global": 617,
+      "is_pos": false,
+      "threshold": 2.6399528980255127,
+      "threshold_int8": 21,
+      "per_dim_F1": 0.6687593460083008
+    },
+    {
+      "dim_index_in_40": 32,
+      "dim_global": 269,
+      "is_pos": false,
+      "threshold": 1.357992172241211,
+      "threshold_int8": 11,
+      "per_dim_F1": 0.6660473942756653
+    },
+    {
+      "dim_index_in_40": 33,
+      "dim_global": 745,
+      "is_pos": false,
+      "threshold": 2.195744514465332,
+      "threshold_int8": 18,
+      "per_dim_F1": 0.6753367185592651
+    },
+    {
+      "dim_index_in_40": 34,
+      "dim_global": 576,
+      "is_pos": false,
+      "threshold": 2.358708620071411,
+      "threshold_int8": 19,
+      "per_dim_F1": 0.6699551939964294
+    },
+    {
+      "dim_index_in_40": 35,
+      "dim_global": 701,
+      "is_pos": false,
+      "threshold": 1.7730076313018799,
+      "threshold_int8": 14,
+      "per_dim_F1": 0.670412540435791
+    },
+    {
+      "dim_index_in_40": 36,
+      "dim_global": 105,
+      "is_pos": false,
+      "threshold": 2.2044856548309326,
+      "threshold_int8": 18,
+      "per_dim_F1": 0.6687593460083008
+    },
+    {
+      "dim_index_in_40": 37,
+      "dim_global": 694,
+      "is_pos": false,
+      "threshold": 2.0147933959960938,
+      "threshold_int8": 16,
+      "per_dim_F1": 0.6694493293762207
+    },
+    {
+      "dim_index_in_40": 38,
+      "dim_global": 82,
+      "is_pos": false,
+      "threshold": 2.640681743621826,
+      "threshold_int8": 21,
+      "per_dim_F1": 0.6809103488922119
+    },
+    {
+      "dim_index_in_40": 39,
+      "dim_global": 283,
+      "is_pos": false,
+      "threshold": 1.7581170797348022,
+      "threshold_int8": 14,
+      "per_dim_F1": 0.6612855195999146
+    }
+  ],
+  "popcount": {
+    "final_threshold": 13,
+    "F1": 0.8764044642448425,
+    "precision": 0.8911290168762207,
+    "recall": 0.8621586561203003
+  },
+  "additive": {
+    "F1": 0.8842884302139282,
+    "precision": 0.8891323208808899,
+    "recall": 0.8794971704483032
+  },
+  "F1_delta_popcount_vs_additive": -0.007883965969085693
+}

pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "one-parameter-classifier"
+version = "0.0.0"
+description = "Image-level person classification on EUPE-ViT-B features with a single free parameter"
+requires-python = ">=3.9"
+dependencies = [
+    "torch>=2.0",
+    "numpy",
+    "pillow",
+    "safetensors",
+    "transformers>=4.40",
+    "huggingface-hub",
+    "pycocotools",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7"]
+synth = ["nosis"]
+
+[tool.setuptools]
+packages = ["common"]
+py-modules = ["infer", "head", "verify", "calibrate", "rtl_gen", "synth"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

rtl/popcount.v

@@ -0,0 +1,39 @@
+// Popcount-reformulated 1-parameter person classifier, runtime thresholds.
+// Generated by rtl_gen.py; do not edit by hand.
+//
+// Inputs are the 40 Stage 0 classifier dims as signed INT8, post-LayerNorm and
+// post-max-pool. Output is one bit. Combinational, no multipliers, no memory.
+
+module person_classifier_popcount (
+    input  signed [7:0] f00, f01, f02, f03, f04, f05, f06, f07, f08, f09,
+    input  signed [7:0] f10, f11, f12, f13, f14, f15, f16, f17, f18, f19,
+    input  signed [7:0] f20, f21, f22, f23, f24, f25, f26, f27, f28, f29,
+    input  signed [7:0] f30, f31, f32, f33, f34, f35, f36, f37, f38, f39,
+    input  signed [7:0] t00, t01, t02, t03, t04, t05, t06, t07, t08, t09,
+    input  signed [7:0] t10, t11, t12, t13, t14, t15, t16, t17, t18, t19,
+    input  signed [7:0] t20, t21, t22, t23, t24, t25, t26, t27, t28, t29,
+    input  signed [7:0] t30, t31, t32, t33, t34, t35, t36, t37, t38, t39,
+    input  signed [5:0] final_threshold,
+    output person_present
+);
+    wire [5:0] count_pos =
+        (f00 > t00) + (f01 > t01) + (f02 > t02) +
+        (f03 > t03) + (f04 > t04) + (f05 > t05) +
+        (f06 > t06) + (f07 > t07) + (f08 > t08) +
+        (f09 > t09) + (f10 > t10) + (f11 > t11) +
+        (f12 > t12) + (f13 > t13) + (f14 > t14) +
+        (f15 > t15) + (f16 > t16) + (f17 > t17) +
+        (f18 > t18) + (f19 > t19);
+
+    wire [5:0] count_neg =
+        (f20 > t20) + (f21 > t21) + (f22 > t22) +
+        (f23 > t23) + (f24 > t24) + (f25 > t25) +
+        (f26 > t26) + (f27 > t27) + (f28 > t28) +
+        (f29 > t29) + (f30 > t30) + (f31 > t31) +
+        (f32 > t32) + (f33 > t33) + (f34 > t34) +
+        (f35 > t35) + (f36 > t36) + (f37 > t37) +
+        (f38 > t38) + (f39 > t39);
+
+    wire signed [6:0] diff = {1'b0, count_pos} - {1'b0, count_neg};
+    assign person_present = diff > final_threshold;
+endmodule

rtl/popcount_folded.v

@@ -0,0 +1,46 @@
+// Popcount-reformulated 1-parameter person classifier, thresholds baked in.
+// Generated by rtl_gen.py; do not edit by hand.
+//
+// Inputs are the 40 Stage 0 classifier dims as signed INT8, post-LayerNorm and
+// post-max-pool. Output is one bit. Combinational, no multipliers, no memory.
+//
+// Per-dim thresholds are the calibrated float values scaled by 8 and rounded.
+
+module person_classifier_popcount_folded (
+    input  signed [7:0] f00, f01, f02, f03, f04, f05, f06, f07, f08, f09,
+    input  signed [7:0] f10, f11, f12, f13, f14, f15, f16, f17, f18, f19,
+    input  signed [7:0] f20, f21, f22, f23, f24, f25, f26, f27, f28, f29,
+    input  signed [7:0] f30, f31, f32, f33, f34, f35, f36, f37, f38, f39,
+    output person_present
+);
+    localparam signed [7:0] T00 =   53, T01 =   56, T02 =   26, T03 =   60, T04 =   17,
+                             T05 =   12, T06 =   16, T07 =    1, T08 =    5, T09 =   11,
+                             T10 =    4, T11 =    4, T12 =    6, T13 =    9, T14 =    8,
+                             T15 =   16, T16 =    6, T17 =    6, T18 =    7, T19 =    8,
+                             T20 =   36, T21 =   45, T22 =   19, T23 =   14, T24 =   14,
+                             T25 =   63, T26 =   18, T27 =   49, T28 =   17, T29 =   17,
+                             T30 =   17, T31 =   21, T32 =   11, T33 =   18, T34 =   19,
+                             T35 =   14, T36 =   18, T37 =   16, T38 =   21, T39 =   14;
+    localparam signed [5:0] FINAL_T = 13;
+
+    wire [5:0] count_pos =
+        (f00 > T00) + (f01 > T01) + (f02 > T02) +
+        (f03 > T03) + (f04 > T04) + (f05 > T05) +
+        (f06 > T06) + (f07 > T07) + (f08 > T08) +
+        (f09 > T09) + (f10 > T10) + (f11 > T11) +
+        (f12 > T12) + (f13 > T13) + (f14 > T14) +
+        (f15 > T15) + (f16 > T16) + (f17 > T17) +
+        (f18 > T18) + (f19 > T19);
+
+    wire [5:0] count_neg =
+        (f20 > T20) + (f21 > T21) + (f22 > T22) +
+        (f23 > T23) + (f24 > T24) + (f25 > T25) +
+        (f26 > T26) + (f27 > T27) + (f28 > T28) +
+        (f29 > T29) + (f30 > T30) + (f31 > T31) +
+        (f32 > T32) + (f33 > T33) + (f34 > T34) +
+        (f35 > T35) + (f36 > T36) + (f37 > T37) +
+        (f38 > T38) + (f39 > T39);
+
+    wire signed [6:0] diff = {1'b0, count_pos} - {1'b0, count_neg};
+    assign person_present = diff > FINAL_T;
+endmodule

rtl/sum.v

@@ -0,0 +1,32 @@
+// Additive 1-parameter person classifier, runtime threshold.
+// Generated by rtl_gen.py; do not edit by hand.
+//
+// Inputs are the 40 Stage 0 classifier dims as signed INT8, post-LayerNorm and
+// post-max-pool. Output is one bit. Combinational, no multipliers, no memory.
+
+module person_classifier_1p (
+    input  signed [7:0] f00, f01, f02, f03, f04, f05, f06, f07, f08, f09,
+    input  signed [7:0] f10, f11, f12, f13, f14, f15, f16, f17, f18, f19,
+    input  signed [7:0] f20, f21, f22, f23, f24, f25, f26, f27, f28, f29,
+    input  signed [7:0] f30, f31, f32, f33, f34, f35, f36, f37, f38, f39,
+    input  signed [15:0] threshold,
+    output person_present
+);
+    // Score = sum(f00..f19) - sum(f20..f39); worst case 20 * 127 = 2540 fits in 16 bits.
+    wire signed [15:0] pos_sum =
+        {{8{f00[7]}}, f00} + {{8{f01[7]}}, f01} + {{8{f02[7]}}, f02} + {{8{f03[7]}}, f03} +
+        {{8{f04[7]}}, f04} + {{8{f05[7]}}, f05} + {{8{f06[7]}}, f06} + {{8{f07[7]}}, f07} +
+        {{8{f08[7]}}, f08} + {{8{f09[7]}}, f09} + {{8{f10[7]}}, f10} + {{8{f11[7]}}, f11} +
+        {{8{f12[7]}}, f12} + {{8{f13[7]}}, f13} + {{8{f14[7]}}, f14} + {{8{f15[7]}}, f15} +
+        {{8{f16[7]}}, f16} + {{8{f17[7]}}, f17} + {{8{f18[7]}}, f18} + {{8{f19[7]}}, f19};
+
+    wire signed [15:0] neg_sum =
+        {{8{f20[7]}}, f20} + {{8{f21[7]}}, f21} + {{8{f22[7]}}, f22} + {{8{f23[7]}}, f23} +
+        {{8{f24[7]}}, f24} + {{8{f25[7]}}, f25} + {{8{f26[7]}}, f26} + {{8{f27[7]}}, f27} +
+        {{8{f28[7]}}, f28} + {{8{f29[7]}}, f29} + {{8{f30[7]}}, f30} + {{8{f31[7]}}, f31} +
+        {{8{f32[7]}}, f32} + {{8{f33[7]}}, f33} + {{8{f34[7]}}, f34} + {{8{f35[7]}}, f35} +
+        {{8{f36[7]}}, f36} + {{8{f37[7]}}, f37} + {{8{f38[7]}}, f38} + {{8{f39[7]}}, f39};
+
+    wire signed [15:0] score = pos_sum - neg_sum;
+    assign person_present = score > threshold;
+endmodule

rtl/sum_folded.v

@@ -0,0 +1,33 @@
+// Additive 1-parameter person classifier, threshold baked in.
+// Generated by rtl_gen.py; do not edit by hand.
+//
+// Inputs are the 40 Stage 0 classifier dims as signed INT8, post-LayerNorm and
+// post-max-pool. Output is one bit. Combinational, no multipliers, no memory.
+
+module person_classifier_sum_folded (
+    input  signed [7:0] f00, f01, f02, f03, f04, f05, f06, f07, f08, f09,
+    input  signed [7:0] f10, f11, f12, f13, f14, f15, f16, f17, f18, f19,
+    input  signed [7:0] f20, f21, f22, f23, f24, f25, f26, f27, f28, f29,
+    input  signed [7:0] f30, f31, f32, f33, f34, f35, f36, f37, f38, f39,
+    output person_present
+);
+    // Stage 0 threshold 25.2845 at the x8 scale used for the per-dim ones.
+    localparam signed [15:0] FINAL_T = 16'sd202;
+
+    wire signed [15:0] pos_sum =
+        {{8{f00[7]}}, f00} + {{8{f01[7]}}, f01} + {{8{f02[7]}}, f02} + {{8{f03[7]}}, f03} +
+        {{8{f04[7]}}, f04} + {{8{f05[7]}}, f05} + {{8{f06[7]}}, f06} + {{8{f07[7]}}, f07} +
+        {{8{f08[7]}}, f08} + {{8{f09[7]}}, f09} + {{8{f10[7]}}, f10} + {{8{f11[7]}}, f11} +
+        {{8{f12[7]}}, f12} + {{8{f13[7]}}, f13} + {{8{f14[7]}}, f14} + {{8{f15[7]}}, f15} +
+        {{8{f16[7]}}, f16} + {{8{f17[7]}}, f17} + {{8{f18[7]}}, f18} + {{8{f19[7]}}, f19};
+
+    wire signed [15:0] neg_sum =
+        {{8{f20[7]}}, f20} + {{8{f21[7]}}, f21} + {{8{f22[7]}}, f22} + {{8{f23[7]}}, f23} +
+        {{8{f24[7]}}, f24} + {{8{f25[7]}}, f25} + {{8{f26[7]}}, f26} + {{8{f27[7]}}, f27} +
+        {{8{f28[7]}}, f28} + {{8{f29[7]}}, f29} + {{8{f30[7]}}, f30} + {{8{f31[7]}}, f31} +
+        {{8{f32[7]}}, f32} + {{8{f33[7]}}, f33} + {{8{f34[7]}}, f34} + {{8{f35[7]}}, f35} +
+        {{8{f36[7]}}, f36} + {{8{f37[7]}}, f37} + {{8{f38[7]}}, f38} + {{8{f39[7]}}, f39};
+
+    wire signed [15:0] score = pos_sum - neg_sum;
+    assign person_present = score > FINAL_T;
+endmodule

rtl_gen.py

@@ -0,0 +1,183 @@
+"""Generate all four RTL variants from per_dim_thresholds.json.
+
+    python rtl_gen.py
+
+Kept separate from calibrate.py so the RTL can be regenerated from the committed
+thresholds without the feature cache the calibration needs.
+"""
+import argparse
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))  # repo root, for `common`
+from common import read_artifact  # noqa: E402
+
+HERE = Path(__file__).resolve().parent
+N_DIMS = 40
+N_POS = 20
+
+HEADER = '''// {title}
+// Generated by rtl_gen.py; do not edit by hand.
+//
+// Inputs are the 40 Stage 0 classifier dims as signed INT8, post-LayerNorm and
+// post-max-pool. Output is one bit. Combinational, no multipliers, no memory.
+'''
+
+
+def _ports(name: str, width: int, per_line: int = 10) -> str:
+    """Declaration lines for f00..f39 or t00..t39."""
+    rows = []
+    for start in range(0, N_DIMS, per_line):
+        names = ', '.join(f'{name}{i:02d}' for i in range(start, start + per_line))
+        rows.append(f'    input  signed [{width - 1}:0] {names},')
+    return '\n'.join(rows)
+
+
+def _sign_extended_sum(lo: int, hi: int, per_line: int = 4) -> str:
+    """Sign-extended 16-bit addition of f{lo}..f{hi-1}."""
+    terms = [f'{{{{8{{f{i:02d}[7]}}}}, f{i:02d}}}' for i in range(lo, hi)]
+    rows = [' + '.join(terms[i:i + per_line]) for i in range(0, len(terms), per_line)]
+    return ' +\n        '.join(rows)
+
+
+def _popcount(lo: int, hi: int, threshold, per_line: int = 3) -> str:
+    """Sum of the per-dim comparisons, written inline.
+
+    The comparisons are summed directly rather than collected into a vector and
+    indexed. Indexing a vector is the more readable form, but it relies on
+    bit-select lowering that the synthesis backend gets wrong at index 0, and a
+    decision circuit is not the place to depend on that.
+    """
+    terms = [f'(f{i:02d} > {threshold(i)})' for i in range(lo, hi)]
+    rows = [' + '.join(terms[i:i + per_line]) for i in range(0, len(terms), per_line)]
+    return ' +\n        '.join(rows)
+
+
+def _threshold_bank(values, per_line: int = 5) -> str:
+    """localparam bank holding the 40 baked INT8 thresholds."""
+    rows = []
+    for start in range(0, N_DIMS, per_line):
+        rows.append(', '.join(f'T{i:02d} = {values[i]:>4}'
+                              for i in range(start, min(start + per_line, N_DIMS))))
+    return (',\n' + ' ' * 29).join(rows)
+
+
+def emit_sum() -> str:
+    return HEADER.format(title='Additive 1-parameter person classifier, runtime threshold.') + f'''
+module person_classifier_1p (
+{_ports('f', 8)}
+    input  signed [15:0] threshold,
+    output person_present
+);
+    // Score = sum(f00..f19) - sum(f20..f39); worst case 20 * 127 = 2540 fits in 16 bits.
+    wire signed [15:0] pos_sum =
+        {_sign_extended_sum(0, 20)};
+
+    wire signed [15:0] neg_sum =
+        {_sign_extended_sum(20, 40)};
+
+    wire signed [15:0] score = pos_sum - neg_sum;
+    assign person_present = score > threshold;
+endmodule
+'''
+
+
+def emit_sum_folded(final_int8: int, final_float: float, quant_scale: int) -> str:
+    return HEADER.format(title='Additive 1-parameter person classifier, threshold baked in.') + f'''
+module person_classifier_sum_folded (
+{_ports('f', 8)}
+    output person_present
+);
+    // Stage 0 threshold {final_float:.4f} at the x{quant_scale} scale used for the per-dim ones.
+    localparam signed [15:0] FINAL_T = 16'sd{final_int8};
+
+    wire signed [15:0] pos_sum =
+        {_sign_extended_sum(0, 20)};
+
+    wire signed [15:0] neg_sum =
+        {_sign_extended_sum(20, 40)};
+
+    wire signed [15:0] score = pos_sum - neg_sum;
+    assign person_present = score > FINAL_T;
+endmodule
+'''
+
+
+def emit_popcount() -> str:
+    title = 'Popcount-reformulated 1-parameter person classifier, runtime thresholds.'
+    return HEADER.format(title=title) + f'''
+module person_classifier_popcount (
+{_ports('f', 8)}
+{_ports('t', 8)}
+    input  signed [5:0] final_threshold,
+    output person_present
+);
+    wire [5:0] count_pos =
+        {_popcount(0, 20, lambda i: f't{i:02d}')};
+
+    wire [5:0] count_neg =
+        {_popcount(20, 40, lambda i: f't{i:02d}')};
+
+    wire signed [6:0] diff = {{1'b0, count_pos}} - {{1'b0, count_neg}};
+    assign person_present = diff > final_threshold;
+endmodule
+'''
+
+
+def emit_popcount_folded(thresholds, final_threshold: int, quant_scale: int) -> str:
+    title = 'Popcount-reformulated 1-parameter person classifier, thresholds baked in.'
+    return HEADER.format(title=title) + f'''//
+// Per-dim thresholds are the calibrated float values scaled by {quant_scale} and rounded.
+
+module person_classifier_popcount_folded (
+{_ports('f', 8)}
+    output person_present
+);
+    localparam signed [7:0] {_threshold_bank(thresholds)};
+    localparam signed [5:0] FINAL_T = {final_threshold};
+
+    wire [5:0] count_pos =
+        {_popcount(0, 20, lambda i: f'T{i:02d}')};
+
+    wire [5:0] count_neg =
+        {_popcount(20, 40, lambda i: f'T{i:02d}')};
+
+    wire signed [6:0] diff = {{1'b0, count_pos}} - {{1'b0, count_neg}};
+    assign person_present = diff > FINAL_T;
+endmodule
+'''
+
+
+def generate(out_dir: Path = None, thresholds_json: Path = None,
+             classifier_json: Path = None):
+    """Write all four modules; returns the paths written."""
+    out_dir = out_dir or HERE / 'rtl'
+    cal = read_artifact(thresholds_json or HERE / 'per_dim_thresholds.json')
+    classifier = json.loads(
+        (classifier_json or HERE / 'classifier.json').read_text())
+
+    scale = cal['quant_scale']
+    per_dim = [p['threshold_int8'] for p in cal['per_dim_thresholds']]
+    final_pop = cal['popcount']['final_threshold']
+    stage_0_thr = float(classifier['threshold'])
+    stage_0_int8 = int(round(stage_0_thr * scale))
+
+    out_dir.mkdir(parents=True, exist_ok=True)
+    written = {
+        'sum.v': emit_sum(),
+        'sum_folded.v': emit_sum_folded(stage_0_int8, stage_0_thr, scale),
+        'popcount.v': emit_popcount(),
+        'popcount_folded.v': emit_popcount_folded(per_dim, final_pop, scale),
+    }
+    for name, text in written.items():
+        (out_dir / name).write_text(text, encoding='utf-8')
+    return [out_dir / n for n in written]
+
+
+if __name__ == '__main__':
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument('--out', type=Path, default=None)
+    args = ap.parse_args()
+    for path in generate(args.out):
+        print(f'wrote {path}')

synth.py

@@ -0,0 +1,86 @@
+"""Synthesize the four decision variants with nosis and write circuit.json.
+
+    python synth.py
+
+nosis is a pure-Python SystemVerilog to Lattice ECP5 synthesizer. Counts are
+LUT4s, carry cells and slices on that device. Adder trees land on the carry
+chain, so CCU2C rather than LUT4 is the resource that moves with the form of the
+decision, and `bound` records which resource limits each variant.
+"""
+import argparse
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))  # repo root, for `common`
+from common import read_artifact, write_artifact  # noqa: E402
+
+HERE = Path(__file__).resolve().parent
+NOSIS_ROOT = Path(r'D:\nosis')
+VARIANTS = {
+    'sum': ('person_classifier_1p', 'runtime input'),
+    'sum_folded': ('person_classifier_sum_folded', 'baked'),
+    'popcount': ('person_classifier_popcount', 'runtime inputs'),
+    'popcount_folded': ('person_classifier_popcount_folded', 'baked'),
+}
+
+
+def synth_one(src: Path, top: str, build: Path, nosis_root: Path):
+    build.mkdir(parents=True, exist_ok=True)
+    r = subprocess.run(
+        [sys.executable, '-m', 'nosis', str(src), '--top', top, '--stats',
+         '-o', str(build / f'{top}.json')],
+        cwd=str(nosis_root), capture_output=True, text=True)
+    if r.returncode != 0:
+        raise SystemExit(f'nosis failed on {src.name}:\n'
+                         f'{r.stdout[-2000:]}{r.stderr[-2000:]}')
+    (build / f'{top}.log').write_text(r.stdout, encoding='utf-8')
+
+    def grab(pattern, cast=int):
+        m = re.search(pattern, r.stdout)
+        return cast(m.group(1)) if m else None
+
+    def text(pattern):
+        m = re.search(pattern, r.stdout)
+        return m.group(1) if m else None
+
+    return {'slices': grab(r'Slices:\s+(\d+)'), 'lut4': grab(r'LUTs:\s+(\d+)'),
+            'ccu2c': grab(r'CCU2C:\s+(\d+)'), 'ffs': grab(r'FFs:\s+(\d+)'),
+            'bound': text(r'Bound:\s+(\S+)'),
+            'critical_path_ns': grab(r'Critical path delay:\s+([\d.]+)', float),
+            'device': text(r'Device:\s+(\S+)')}
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument('--rtl', type=Path, default=HERE / 'rtl')
+    ap.add_argument('--build', type=Path, default=HERE / 'build')
+    ap.add_argument('--nosis', type=Path, default=NOSIS_ROOT)
+    ap.add_argument('--out', type=Path, default=HERE / 'circuit.json')
+    args = ap.parse_args()
+
+    accuracy = read_artifact(args.out)['accuracy']
+    variants = {}
+    print(f"{'variant':>18}{'slices':>8}{'LUT4':>7}{'CCU2C':>7}{'bound':>7}{'ns':>8}")
+    for name, (top, thresholds) in VARIANTS.items():
+        src = args.rtl / f'{name}.v'
+        if not src.exists():
+            raise SystemExit(f'{src} missing; run rtl_gen.py first')
+        s = synth_one(src, top, args.build, args.nosis)
+        s.update({'rtl': f'rtl/{name}.v', 'thresholds': thresholds})
+        variants[name] = s
+        print(f'{name:>18}{s["slices"]:>8}{s["lut4"]:>7}{s["ccu2c"]:>7}'
+              f'{s["bound"]:>7}{s["critical_path_ns"]:>8.2f}', flush=True)
+
+    device = next((v['device'] for v in variants.values() if v['device']), None)
+    write_artifact(args.out, {'variants': variants, 'accuracy': accuracy},
+                   generator='synth.py',
+                   tool='nosis', target={'family': 'ecp5', 'device': device},
+                   inputs='40 signed INT8 feature channels at the classifier dims',
+                   note='LUT4, carry and slice counts on an ECP5, not abstract gates')
+    print(f'\n[done] wrote {args.out}')
+
+
+if __name__ == '__main__':
+    main()

tests/conftest.py

@@ -0,0 +1,29 @@
+"""Shared fixtures and helpers for the consistency suite."""
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+REPO = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(REPO))
+
+
+def load(rel: str) -> dict:
+    """Parse a repo-relative JSON file."""
+    return json.loads((REPO / rel).read_text(encoding='utf-8'))
+
+
+@pytest.fixture(scope='session')
+def repo() -> Path:
+    return REPO
+
+
+@pytest.fixture(scope='session')
+def classifier() -> dict:
+    return load('classifier.json')
+
+
+@pytest.fixture(scope='session')
+def tight() -> dict:
+    return load('classifier_tight_fpr.json')

tests/test_artifacts.py

@@ -0,0 +1,68 @@
+"""Every committed artifact matches the schema its generator declares."""
+import pytest
+
+from common.artifacts import REGISTRY
+from conftest import REPO, load
+
+# Artifacts whose producing sweep was never committed, so provenance.generator
+# is null. A new entry here is a new gap and has to be added deliberately.
+KNOWN_GAPS = {
+    'eval_tight_fpr.json',
+    'discovery/dim_selection.json',
+    'discovery/dim48_characterization.json',
+    'discovery/prop_specificity.json',
+    'discovery/prop_image_manifest.json',
+    'discovery/variant_leaderboard.json',
+}
+
+
+@pytest.mark.parametrize('rel', sorted(REGISTRY))
+def test_artifact_exists(rel):
+    assert (REPO / rel).exists(), f'{rel} is registered but missing'
+
+
+@pytest.mark.parametrize('rel', sorted(REGISTRY))
+def test_artifact_has_provenance(rel):
+    doc = load(rel)
+    assert 'provenance' in doc, f'{rel} has no provenance block'
+    assert next(iter(doc)) == 'provenance', f'{rel} does not open with its provenance block'
+
+
+@pytest.mark.parametrize('rel', sorted(r for r in REGISTRY if REGISTRY[r].payload_keys))
+def test_artifact_payload_keys(rel):
+    spec = REGISTRY[rel]
+    got = tuple(k for k in load(rel) if k != 'provenance')
+    assert got == spec.payload_keys, f'{rel} payload keys {got} != declared {spec.payload_keys}'
+
+
+@pytest.mark.parametrize('rel', sorted(REGISTRY))
+def test_artifact_generator(rel):
+    spec = REGISTRY[rel]
+    generator = load(rel)['provenance']['generator']
+    assert generator in (spec.generator, None), \
+        f'{rel} claims generator {generator!r}, registry says {spec.generator!r}'
+
+
+@pytest.mark.parametrize('rel', sorted(REGISTRY))
+def test_artifact_pool(rel):
+    spec = REGISTRY[rel]
+    pool = load(rel)['provenance'].get('pool')
+    if spec.pool is not None and pool is not None:
+        assert pool == spec.pool, f'{rel} names pool {pool!r}, registry says {spec.pool!r}'
+
+
+def test_known_gaps_are_exactly_the_ungenerated_artifacts():
+    ungenerated = {rel for rel in REGISTRY
+                   if load(rel)['provenance']['generator'] is None}
+    assert ungenerated == KNOWN_GAPS
+
+
+def test_classifier_hashes_are_current():
+    """Every artifact naming a classifier config records that file's current hash."""
+    from common.artifacts import sha256_of
+    for rel in sorted(REGISTRY):
+        p = load(rel)['provenance']
+        if 'classifier' not in p:
+            continue
+        assert p['classifier_sha256'] == sha256_of(REPO / p['classifier']), \
+            f'{rel} pins a stale hash for {p["classifier"]}'

tests/test_dims.py

@@ -0,0 +1,64 @@
+"""The 40 classifier dims agree everywhere they are written down."""
+from safetensors.torch import load_file
+
+from conftest import REPO, load
+
+N_POS = 20
+N_NEG = 20
+
+
+def test_baseline_counts(classifier):
+    assert len(classifier['pos_dims']) == N_POS
+    assert len(classifier['neg_dims']) == N_NEG
+    assert not set(classifier['pos_dims']) & set(classifier['neg_dims'])
+    assert classifier['fixed_parameters']['dim_indices'] == N_POS + N_NEG
+    assert classifier['free_parameters'] == 1
+
+
+def test_tight_fpr_extends_the_baseline(classifier, tight):
+    assert tight['pos_dims'] == classifier['pos_dims']
+    assert tight['neg_dims_original'] == classifier['neg_dims']
+    assert tight['neg_dims'] == tight['neg_dims_original'] + tight['neg_dims_extra']
+    assert len(set(tight['neg_dims'])) == len(tight['neg_dims'])
+    assert tight['fixed_parameters']['dim_indices'] == len(tight['pos_dims']) + len(tight['neg_dims'])
+
+
+def test_leaderboard_prefixes_match_the_shipped_lists(classifier):
+    board = load('discovery/variant_leaderboard.json')
+    assert board['top_pos_dims_30'][:N_POS] == classifier['pos_dims']
+    assert board['top_neg_dims_30'][:N_NEG] == classifier['neg_dims']
+
+
+def test_tight_fpr_extra_dims_come_from_the_prop_sweep(tight):
+    sweep = load('discovery/prop_specificity.json')
+    k = len(tight['neg_dims_extra'])
+    row = next(s for s in sweep['sweeps'] if s['extra_neg_k'] == k)
+    assert row['added_dims'] == tight['neg_dims_extra']
+    assert abs(row['threshold'] - tight['threshold']) < 1e-6
+
+
+def test_per_dim_thresholds_index_the_same_dims(classifier):
+    cal = load('per_dim_thresholds.json')
+    entries = cal['per_dim_thresholds']
+    assert [e['dim_global'] for e in entries] == classifier['pos_dims'] + classifier['neg_dims']
+    assert [e['dim_index_in_40'] for e in entries] == list(range(N_POS + N_NEG))
+    assert [e['is_pos'] for e in entries] == [True] * N_POS + [False] * N_NEG
+
+
+def test_quantized_thresholds_match_their_floats():
+    cal = load('per_dim_thresholds.json')
+    scale = cal['quant_scale']
+    for e in cal['per_dim_thresholds']:
+        assert e['threshold_int8'] == round(e['threshold'] * scale)
+        assert -128 <= e['threshold_int8'] <= 127
+
+
+def test_safetensors_agree_with_the_json_configs(classifier, tight):
+    for name, c in (('classifier', classifier), ('classifier_tight_fpr', tight)):
+        t = load_file(str(REPO / f'{name}.safetensors'))
+        assert t['pos_dims'].tolist() == c['pos_dims']
+        assert t['neg_dims'].tolist() == c['neg_dims']
+        assert t['retained_dims'].tolist() == c['pos_dims'] + c['neg_dims']
+        assert abs(float(t['threshold'][0]) - c['threshold']) < 1e-4
+        w = t['retained_weight'][0].tolist()
+        assert w == [1.0] * len(c['pos_dims']) + [-1.0] * len(c['neg_dims'])

tests/test_head.py

@@ -0,0 +1,38 @@
+"""The fused linear head is identical to the ternary sum it replaces."""
+import sys
+
+import torch
+
+from common import D, score
+from conftest import REPO
+
+sys.path.insert(0, str(REPO))
+from head import FusedClassifier  # noqa: E402
+
+
+def test_fused_head_equals_ternary_score(classifier):
+    torch.manual_seed(0)
+    model = FusedClassifier.from_config(None, REPO / 'classifier.json').eval()
+    pooled = torch.randn(64, D) * 4.0
+    fused, present = model.head(pooled)
+    direct = score(pooled, classifier['pos_dims'], classifier['neg_dims'])
+    assert torch.allclose(fused, direct, atol=1e-4)
+    assert torch.equal(present, direct > classifier['threshold'])
+
+
+def test_only_the_threshold_is_learnable(classifier):
+    model = FusedClassifier.from_config(None, REPO / 'classifier.json')
+    learnable = [n for n, p in model.named_parameters() if p.requires_grad]
+    assert learnable == ['threshold']
+    assert sum(p.numel() for p in model.parameters()) == 1
+
+
+def test_tight_fpr_head_reads_its_own_dim_count(tight):
+    model = FusedClassifier.from_config(
+        None, REPO / 'classifier_tight_fpr.json')
+    assert model.retained_dims.numel() == len(tight['pos_dims']) + len(tight['neg_dims'])
+    torch.manual_seed(1)
+    pooled = torch.randn(32, D) * 4.0
+    fused, _ = model.head(pooled)
+    direct = score(pooled, tight['pos_dims'], tight['neg_dims'])
+    assert torch.allclose(fused, direct, atol=1e-4)

tests/test_rtl.py

@@ -0,0 +1,245 @@
+"""The generated RTL carries the calibrated constants and computes the decision.
+
+The constant and structural checks run everywhere. The simulation checks run
+when Icarus Verilog is available, either on PATH or via the IVERILOG and VVP
+environment variables.
+"""
+import os
+import re
+import shutil
+import subprocess
+
+import pytest
+
+from conftest import REPO, load
+
+RTL = REPO / 'rtl'
+N_DIMS = 40
+N_POS = 20
+N_VECTORS = 512
+
+
+def tool(name, env_var):
+    return os.environ.get(env_var) or shutil.which(name)
+
+
+IVERILOG = tool('iverilog', 'IVERILOG')
+VVP = tool('vvp', 'VVP')
+needs_sim = pytest.mark.skipif(not (IVERILOG and VVP),
+                               reason='Icarus Verilog not found on PATH or in IVERILOG/VVP')
+
+
+@pytest.fixture(scope='module')
+def calibration():
+    return load('per_dim_thresholds.json')
+
+
+def source(name: str) -> str:
+    return (RTL / f'{name}.v').read_text(encoding='utf-8')
+
+
+# ---------------- constants and structure ----------------
+
+def test_baked_per_dim_thresholds_match_the_calibration(calibration):
+    text = source('popcount_folded')
+    baked = {int(i): int(v) for i, v in re.findall(r'T(\d\d) =\s*(-?\d+)', text)}
+    assert len(baked) == N_DIMS
+    for e in calibration['per_dim_thresholds']:
+        assert baked[e['dim_index_in_40']] == e['threshold_int8']
+
+
+def test_baked_final_threshold_matches_the_calibration(calibration):
+    text = source('popcount_folded')
+    assert int(re.search(r'FINAL_T = (-?\d+);', text).group(1)) == \
+        calibration['popcount']['final_threshold']
+
+
+def test_sum_folded_threshold_is_the_quantized_threshold(classifier, calibration):
+    text = source('sum_folded')
+    baked = int(re.search(r"FINAL_T = 16'sd(-?\d+);", text).group(1))
+    assert baked == round(classifier['threshold'] * calibration['quant_scale'])
+
+
+@pytest.mark.parametrize('name,threshold', [('popcount', 't{:02d}'),
+                                            ('popcount_folded', 'T{:02d}')])
+def test_each_channel_is_compared_against_its_own_threshold(name, threshold):
+    text = source(name)
+    pairs = re.findall(r'\(f(\d\d) > (\w+)\)', text)
+    assert len(pairs) == N_DIMS
+    for feature, thr in pairs:
+        assert thr == threshold.format(int(feature))
+    assert [int(f) for f, _ in pairs] == list(range(N_DIMS))
+
+
+@pytest.mark.parametrize('name', ['popcount', 'popcount_folded'])
+def test_no_bit_select_on_a_vector(name):
+    """Bit-select lowering is unreliable at index 0 in the synthesis backend.
+
+    The comparisons are summed inline instead, so nothing here depends on it.
+    """
+    text = '\n'.join(l for l in source(name).splitlines()
+                     if not l.strip().startswith('//'))
+    assert not re.search(r'\b(pos|neg)_bits\b', text)
+
+
+@pytest.mark.parametrize('name', ['sum', 'sum_folded', 'popcount', 'popcount_folded'])
+def test_every_feature_port_is_declared_once(name):
+    declared = re.findall(r'\bf(\d\d)\b(?=[,)\s])', source(name).split(');')[0])
+    assert sorted(set(declared)) == [f'{i:02d}' for i in range(N_DIMS)]
+
+
+# ---------------- simulation ----------------
+
+def vectors(n: int, seed: int = 0):
+    """Deterministic signed-INT8 feature vectors, uniform over the input range."""
+    import random
+    rng = random.Random(seed)
+    return [[rng.randint(-128, 127) for _ in range(N_DIMS)] for _ in range(n)]
+
+
+def popcount_boundary_vectors(thresholds, k: int, n: int, seed: int = 0):
+    """Vectors placing the count difference within two of K, on the per-dim thresholds.
+
+    An `off` channel sits at exactly its threshold, so `>` must reject it.
+    """
+    import random
+    rng = random.Random(seed)
+    out = []
+    while len(out) < n:
+        diff = k + rng.randint(-2, 2)
+        n_neg = rng.randint(0, max(0, N_POS - abs(diff)))
+        n_pos = diff + n_neg
+        if not (0 <= n_pos <= N_POS and 0 <= n_neg <= N_POS):
+            continue
+        pos_on = [True] * n_pos + [False] * (N_POS - n_pos)
+        neg_on = [True] * n_neg + [False] * (N_POS - n_neg)
+        rng.shuffle(pos_on)
+        rng.shuffle(neg_on)
+        on = pos_on + neg_on
+        vec = [max(-128, min(127, t + 1)) if on[i] else max(-128, min(127, t))
+               for i, t in enumerate(thresholds)]
+        out.append(vec)
+    return out
+
+
+def additive_boundary_vectors(threshold: int, n: int, seed: int = 0):
+    """Vectors whose signed sum lands within a few counts of the comparator threshold."""
+    import random
+    rng = random.Random(seed)
+    out = []
+    while len(out) < n:
+        vec = [rng.randint(-20, 20) for _ in range(N_DIMS)]
+        target = threshold + rng.randint(-4, 4)
+        # Solve f00 so that sum(pos) - sum(neg) hits the target exactly.
+        vec[0] = target - (sum(vec[1:N_POS]) - sum(vec[N_POS:]))
+        if -128 <= vec[0] <= 127:
+            out.append(vec)
+    return out
+
+
+def additive_reference(vec, threshold):
+    return (sum(vec[:N_POS]) - sum(vec[N_POS:])) > threshold
+
+
+def popcount_reference(vec, thresholds, k):
+    pos = sum(1 for i in range(N_POS) if vec[i] > thresholds[i])
+    neg = sum(1 for i in range(N_POS, N_DIMS) if vec[i] > thresholds[i])
+    return (pos - neg) > k
+
+
+def literal(value: int, width: int) -> str:
+    return f"-{width}'sd{-value}" if value < 0 else f"{width}'sd{value}"
+
+
+def make_testbench(module: str, extra_ports: str, n: int) -> str:
+    features = ', '.join(f'f{i:02d}' for i in range(N_DIMS))
+    connections = ',\n        '.join(f'.f{i:02d}(f{i:02d})' for i in range(N_DIMS))
+    slices = '\n      '.join(
+        f'f{i:02d} = vecs[i][{319 - 8 * i}:{312 - 8 * i}];' for i in range(N_DIMS))
+    return f'''`timescale 1ns/1ps
+module tb;
+  reg [319:0] vecs [0:{n - 1}];
+  reg signed [7:0] {features};
+  wire out;
+  integer i;
+  {module} dut (
+        {connections},{extra_ports}
+        .person_present(out));
+  initial begin
+    $readmemh("vectors.hex", vecs);
+    for (i = 0; i < {n}; i = i + 1) begin
+      {slices}
+      #1;
+      $display("%b", out);
+    end
+    $finish;
+  end
+endmodule
+'''
+
+
+def run_sim(tmp_path, rtl_name, module, extra_ports, vecs):
+    tmp_path.mkdir(parents=True, exist_ok=True)
+    hexfile = tmp_path / 'vectors.hex'
+    hexfile.write_text('\n'.join(
+        ''.join(f'{v & 0xFF:02x}' for v in vec) for vec in vecs) + '\n')
+    (tmp_path / 'tb.v').write_text(make_testbench(module, extra_ports, len(vecs)))
+    subprocess.run([IVERILOG, '-g2005', '-o', 'tb.vvp',
+                    str(RTL / f'{rtl_name}.v'), 'tb.v'],
+                   cwd=tmp_path, check=True, capture_output=True)
+    out = subprocess.run([VVP, 'tb.vvp'], cwd=tmp_path, check=True,
+                         capture_output=True, text=True).stdout
+    bits = [line.strip() for line in out.splitlines() if line.strip() in ('0', '1')]
+    assert len(bits) == len(vecs), f'{module}: {len(bits)} results for {len(vecs)} vectors'
+    return [b == '1' for b in bits]
+
+
+@needs_sim
+def test_sum_matches_the_additive_reference(tmp_path, classifier, calibration):
+    thr = round(classifier['threshold'] * calibration['quant_scale'])
+    vecs = vectors(N_VECTORS) + additive_boundary_vectors(thr, N_VECTORS)
+    got = run_sim(tmp_path, 'sum', 'person_classifier_1p',
+                  f'\n        .threshold({literal(thr, 16)}),', vecs)
+    assert got == [additive_reference(v, thr) for v in vecs]
+
+
+@needs_sim
+def test_sum_folded_matches_the_additive_reference(tmp_path, classifier, calibration):
+    thr = round(classifier['threshold'] * calibration['quant_scale'])
+    vecs = vectors(N_VECTORS) + additive_boundary_vectors(thr, N_VECTORS)
+    got = run_sim(tmp_path, 'sum_folded', 'person_classifier_sum_folded', '', vecs)
+    assert got == [additive_reference(v, thr) for v in vecs]
+
+
+@needs_sim
+def test_popcount_matches_the_popcount_reference(tmp_path, calibration):
+    thresholds = [e['threshold_int8'] for e in calibration['per_dim_thresholds']]
+    k = calibration['popcount']['final_threshold']
+    ports = ''.join(f'\n        .t{i:02d}({literal(t, 8)}),'
+                    for i, t in enumerate(thresholds))
+    ports += f'\n        .final_threshold({literal(k, 6)}),'
+    vecs = vectors(N_VECTORS) + popcount_boundary_vectors(thresholds, k, N_VECTORS)
+    got = run_sim(tmp_path, 'popcount', 'person_classifier_popcount', ports, vecs)
+    assert got == [popcount_reference(v, thresholds, k) for v in vecs]
+
+
+@needs_sim
+def test_popcount_folded_matches_the_popcount_reference(tmp_path, calibration):
+    thresholds = [e['threshold_int8'] for e in calibration['per_dim_thresholds']]
+    k = calibration['popcount']['final_threshold']
+    vecs = vectors(N_VECTORS) + popcount_boundary_vectors(thresholds, k, N_VECTORS)
+    got = run_sim(tmp_path, 'popcount_folded', 'person_classifier_popcount_folded',
+                  '', vecs)
+    assert got == [popcount_reference(v, thresholds, k) for v in vecs]
+
+
+@needs_sim
+def test_folding_a_threshold_does_not_change_the_decision(tmp_path, classifier,
+                                                          calibration):
+    """Each runtime-threshold module agrees with its baked counterpart."""
+    thr = round(classifier['threshold'] * calibration['quant_scale'])
+    vecs = vectors(N_VECTORS, seed=1) + additive_boundary_vectors(thr, N_VECTORS, seed=1)
+    runtime = run_sim(tmp_path / 'a', 'sum', 'person_classifier_1p',
+                      f'\n        .threshold({literal(thr, 16)}),', vecs)
+    baked = run_sim(tmp_path / 'b', 'sum_folded', 'person_classifier_sum_folded', '', vecs)
+    assert runtime == baked

verify.py

@@ -0,0 +1,66 @@
+"""Score a classifier config over a named pool and write its eval artifact.
+
+    python verify.py                                  # baseline on VAL5000
+    python verify.py --classifier classifier_tight_fpr.json
+    python verify.py --pool CALIB1000
+
+Writes eval.json for the baseline config and eval_tight_fpr.json for the
+tight-FPR one, unless --out says otherwise.
+"""
+import argparse
+import json
+import sys
+from pathlib import Path
+
+import torch
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))  # repo root, for `common`
+from common import BACKBONE, device, f1_at, load_pool, score_pool, write_artifact  # noqa: E402
+from common.models import load_backbone  # noqa: E402
+from common.pools import VAL5000, by_name  # noqa: E402
+
+HERE = Path(__file__).resolve().parent
+
+
+def out_path_for(classifier: Path) -> Path:
+    """classifier.json -> eval.json; classifier_tight_fpr.json -> eval_tight_fpr.json."""
+    suffix = classifier.stem[len('classifier'):]
+    return classifier.parent / f'eval{suffix}.json'
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument('--classifier', type=Path, default=HERE / 'classifier.json')
+    ap.add_argument('--backbone', default=BACKBONE)
+    ap.add_argument('--pool', default=VAL5000.name)
+    ap.add_argument('--out', type=Path, default=None)
+    args = ap.parse_args()
+
+    dev = device()
+    pool = by_name(args.pool)
+    c = json.loads(args.classifier.read_text())
+    print(f'[init] loading {args.backbone}', flush=True)
+    backbone = load_backbone(args.backbone).to(dev)
+
+    print(f'[pool] {pool.name}', flush=True)
+    loaded = load_pool(pool, dev)
+    pos = torch.tensor(c['pos_dims'], dtype=torch.long, device=dev)
+    neg = torch.tensor(c['neg_dims'], dtype=torch.long, device=dev)
+
+    scores, _ = score_pool(backbone, loaded, pos, neg)
+    m = f1_at(scores, loaded.labels, c['threshold'])
+    print(f'[verify] F1={m.f1:.4f}  P={m.precision:.4f}  R={m.recall:.4f}', flush=True)
+
+    path = args.out or out_path_for(args.classifier)
+    write_artifact(
+        path, {'metrics': {k: round(v, 4) if k != 'threshold' else v
+                           for k, v in m.asdict().items()}},
+        generator='verify.py', classifier=args.classifier,
+        pool_info=loaded.provenance(),
+        task='image-level person presence (binary)',
+        protocol='live backbone forward at 768 px, no feature caching')
+    print(f'[done] wrote {path}', flush=True)
+
+
+if __name__ == '__main__':
+    main()