code/ster_diagnostic.py

"""
STER — Difficulty / Headroom Diagnostic.

Goal: the CLEAN Hague matching baseline is ~F1 0.95 (near-solved), so we must find
WHERE the ratio+classifier baseline actually breaks, i.e. which scenarios have room
for a new method. Uses ONLY cached property dicts + partition pairs (no crawl).

Measures:
  (0) Baseline   : full-train Bagging on full test  -> confirms ~0.95
  (1) Few-shot   : train on K positive pairs (+2K neg) -> F1(K) curve
  (2) Long-tail  : split TEST by candidate size (volume) into head/tail -> F1 per stratum
  (3) Discrepancy: split TEST by cross-source geometric discrepancy -> F1 per bin
                   (proxy for the 'noisy' regime without needing multi-LoD crawl)
"""
import os, json, warnings, numpy as np, joblib
warnings.filterwarnings("ignore")
from sklearn.ensemble import BaggingClassifier
from sklearn.metrics import f1_score, precision_score, recall_score

SEED = 1
PROP_DIR = "data/property_dicts"
PART = "data/dataset_partitions/Hague_seed1.pkl"
TRAIN_PD = f"{PROP_DIR}/Hague_130425_train_matching_small_neg_samples_num=2_vector_normalization=True_seed=1.joblib"
TEST_PD = f"{PROP_DIR}/Hague_130425_test_matching_small_neg_samples_num=2_vector_normalization=True_seed=1.joblib"
MAX_RATIO = 1000.0
rng = np.random.RandomState(SEED)

print("Loading cached property dicts + partition ...", flush=True)
train_pd = joblib.load(TRAIN_PD)
test_pd = joblib.load(TEST_PD)
part = joblib.load(PART)
PROPS = list(train_pd.keys())
print(f"  {len(PROPS)} properties")

train_pairs = part['train']['blocking-based']['small'][2]
test_pairs = part['test']['matching']['blocking-based']['small'][2]


def build_xy(pairs, pd):
    """Return X (ratio features), y (label = cand_id==index_id), and cand raw log-size."""
    X, y = [], []
    cand_size, discrepancy = [], []
    for c, i in pairs:
        row = []
        logdev = []
        ok = True
        for p in PROPS:
            try:
                cv = pd[p]['cands'][c]; iv = pd[p]['index'][i]
                r = min(MAX_RATIO, round(cv / iv, 3)) if iv != 0 else MAX_RATIO
            except KeyError:
                ok = False; break
            row.append(r)
            # discrepancy in log-space: |log(cv)-log(iv)| approximated by |cv-iv| (already log1p'd)
            logdev.append(abs(cv - iv))
        if not ok:
            continue
        X.append(row); y.append(1 if c == i else 0)
        cand_size.append(pd['volume']['cands'][c])         # log1p volume of candidate
        discrepancy.append(float(np.mean(logdev)))         # mean per-prop log-discrepancy
    return (np.array(X), np.array(y), np.array(cand_size), np.array(discrepancy))


print("Building feature matrices ...", flush=True)
Xtr, ytr, _, _ = build_xy(train_pairs, train_pd)
Xte, yte, size_te, disc_te = build_xy(test_pairs, test_pd)
print(f"  train X={Xtr.shape} pos={ytr.sum()} | test X={Xte.shape} pos={yte.sum()}", flush=True)


def fit_eval(Xtr, ytr, Xte, yte, n_estimators=50):
    clf = BaggingClassifier(n_estimators=n_estimators, random_state=SEED)
    clf.fit(Xtr, ytr)
    pred = clf.predict(Xte)
    return dict(precision=round(precision_score(yte, pred, zero_division=0), 4),
                recall=round(recall_score(yte, pred, zero_division=0), 4),
                f1=round(f1_score(yte, pred, zero_division=0), 4))


report = {}

# (0) Baseline
print("\n[0] Baseline (full train -> full test)", flush=True)
base = fit_eval(Xtr, ytr, Xte, yte)
print("   ", base, flush=True)
report['baseline_full'] = base

# (1) Few-shot: K positive pairs + 2K negatives
print("\n[1] Few-shot curve", flush=True)
pos_idx = np.where(ytr == 1)[0]; neg_idx = np.where(ytr == 0)[0]
fewshot = {}
for K in [1, 3, 5, 10, 20, 50, 100]:
    if K > len(pos_idx):
        break
    accs = []
    for rep in range(5):  # average over 5 random label sets
        r = np.random.RandomState(100 + rep)
        ps = r.choice(pos_idx, K, replace=False)
        ns = r.choice(neg_idx, min(2 * K, len(neg_idx)), replace=False)
        idx = np.concatenate([ps, ns])
        accs.append(fit_eval(Xtr[idx], ytr[idx], Xte, yte, n_estimators=30)['f1'])
    fewshot[K] = dict(f1_mean=round(float(np.mean(accs)), 4), f1_std=round(float(np.std(accs)), 4))
    print(f"    K={K:3d} -> F1={fewshot[K]['f1_mean']:.4f} ±{fewshot[K]['f1_std']:.4f}", flush=True)
report['few_shot'] = fewshot

# (2) Long-tail: split test by candidate volume (rare large buildings = tail)
print("\n[2] Long-tail (test split by candidate volume)", flush=True)
clf = BaggingClassifier(n_estimators=50, random_state=SEED).fit(Xtr, ytr)
pred_te = clf.predict(Xte)
q_hi = np.quantile(size_te, 0.90)   # top 10% largest = tail
q_lo = np.quantile(size_te, 0.10)
longtail = {}
for name, mask in [('head_common_mid', (size_te > q_lo) & (size_te <= q_hi)),
                   ('tail_large_top10', size_te > q_hi),
                   ('tail_small_bot10', size_te <= q_lo)]:
    if mask.sum() == 0:
        continue
    longtail[name] = dict(n=int(mask.sum()),
                          f1=round(f1_score(yte[mask], pred_te[mask], zero_division=0), 4),
                          recall=round(recall_score(yte[mask], pred_te[mask], zero_division=0), 4))
    print(f"    {name:20s} n={mask.sum():5d} F1={longtail[name]['f1']:.4f}", flush=True)
report['long_tail'] = longtail

# (3) Discrepancy-stratified: F1 vs cross-source geometric discrepancy
print("\n[3] Discrepancy-stratified (test split by cand-index geometric gap)", flush=True)
bins = np.quantile(disc_te, [0, 0.25, 0.5, 0.75, 0.9, 1.0])
disc = {}
for b in range(len(bins) - 1):
    lo, hi = bins[b], bins[b + 1]
    mask = (disc_te >= lo) & (disc_te <= hi if b == len(bins) - 2 else disc_te < hi)
    if mask.sum() == 0:
        continue
    disc[f"q{b}"] = dict(range=[round(float(lo), 3), round(float(hi), 3)], n=int(mask.sum()),
                         f1=round(f1_score(yte[mask], pred_te[mask], zero_division=0), 4),
                         recall=round(recall_score(yte[mask], pred_te[mask], zero_division=0), 4))
    print(f"    q{b} disc∈[{lo:.2f},{hi:.2f}] n={mask.sum():5d} F1={disc[f'q{b}']['f1']:.4f}", flush=True)
report['discrepancy'] = disc

os.makedirs("../../experiments/diagnostic", exist_ok=True)
with open("../../experiments/diagnostic/headroom_diagnostic.json", "w") as f:
    json.dump(report, f, indent=2)
print("\nSaved -> experiments/diagnostic/headroom_diagnostic.json", flush=True)