Download src/heuristic/scripts/old/06_evaluate.py from NicoloLocatelli/RecSys_ACM_2026_Hallucinated: direct link, hf CLI and curl.
- Browser
- Download file 8.21 kB
-
https://huggingface.co/datasets/NicoloLocatelli/RecSys_ACM_2026_Hallucinated/resolve/main/src/heuristic/scripts/old/06_evaluate.py
- Command line
-
hf download hf://datasets/NicoloLocatelli/RecSys_ACM_2026_Hallucinated/src/heuristic/scripts/old/06_evaluate.py
-
curl -L -o 06_evaluate.py https://huggingface.co/datasets/NicoloLocatelli/RecSys_ACM_2026_Hallucinated/resolve/main/src/heuristic/scripts/old/06_evaluate.py
8.21 kB
| """End-to-end recall + heatmap evaluation for one encoder. | |
| ────────────────────────────────────────────────────────────────────────────── | |
| WHAT CHANGED FOR THE QWEN3-NATIVE PIPELINE | |
| ────────────────────────────────────────────────────────────────────────────── | |
| 1. New folds `val` and `test` evaluate on the Blind-A-matched split | |
| (scripts/01b_rebuild_split.py). Their sessions come from the organizer TRAIN | |
| conversation parquet, so their query embeddings live under the "train" cache | |
| key — we load that, then SUBSET to exactly the pinned predict-turn rows for | |
| the fold (one per session). `dev` and `blind_a` behave as before. | |
| 2. Track-tower routing sends the Qwen3-native encoders to OUR Qwen3-native tower | |
| (models/track_tower_qwen_cache, 1024-d): | |
| qwen3_native_frozen, qwen3_lora__* → metadata-qwen3-native (NEW) | |
| qwen3_frozen, keyword_*_qwen3 → organizer metadata-qwen3 (legacy) | |
| bert_*, sbert_*, modernbert_* → per-backbone text tower (768-d) | |
| 3. Reports are written to models/eval_results/<encoder>/<fold>/recall.json so | |
| scripts/07_compare_all.py --split val (or test) picks them up unchanged. | |
| """ | |
| from __future__ import annotations | |
| import argparse | |
| import sys | |
| from pathlib import Path | |
| import numpy as np | |
| import polars as pl | |
| sys.path.insert(0, str(Path(__file__).resolve().parents[1])) | |
| from emblib.data.split import ( | |
| load_blinda_split, turn_pairs_for_fold, select_pair_indices, | |
| ) | |
| from emblib.evaluation.recall import ( | |
| DEFAULT_KS, compute_topk, compute_recall, save_heatmaps, save_report, | |
| ) | |
| from emblib.tracks.organizer_track_loader import load_track_tower | |
| from emblib.tracks.qwen_track_loader import load_qwen_track_tower, QWEN_MODALITY | |
| from emblib.tracks.text_track_loader import ( | |
| load_text_track_tower, get_modality_name as get_text_modality, | |
| ) | |
| DATA = Path("./data/talkpl-ai") | |
| TOWER_CACHE = Path("./models/track_tower_cache") | |
| QWEN_TOWER_CACHE = Path("./models/track_tower_qwen_cache") | |
| TEXT_TOWER_CACHE = Path("./models/track_tower_text_cache") | |
| QUERY_CACHE = Path("./models/query_emb_cache") | |
| EVAL_OUT = Path("./models/eval_results") | |
| SPLITS_PATH = Path("./models/splits/train_val_test_blinda_matched.parquet") | |
| LEGACY_QWEN3_MODALITY = "metadata-qwen3_embedding_0.6b" | |
| # Which cached conversation split each eval fold reads its query embeddings from. | |
| # val/test sessions are organizer-train-derived, so their queries are encoded | |
| # under the "train" key (and then subset to predict-turn rows). | |
| FOLD_TO_CONV_SPLIT = {"val": "train", "test": "train", "dev": "dev", "blind_a": "blind_a"} | |
| def load_tower_for_encoder(encoder_name: str): | |
| """Choose the track tower based on the encoder cache name's prefix. | |
| Returns (track_emb, track_mask, id_to_idx). | |
| """ | |
| # *_native_frozen and *_proj_* HF encoders match against the backbone's | |
| # own native-space text tower. | |
| if encoder_name.startswith("bert_native_frozen") or encoder_name.startswith("bert_proj_"): | |
| backbone = "bert" | |
| elif encoder_name.startswith("sbert_native_frozen") or encoder_name.startswith("sbert_proj_"): | |
| backbone = "sbert" | |
| elif encoder_name.startswith("modernbert_native_frozen") or encoder_name.startswith("modernbert_proj_"): | |
| backbone = "modernbert" | |
| elif encoder_name.startswith("qwen3_native_frozen") or encoder_name.startswith("qwen3_lora"): | |
| # NEW: query mirror of OUR Qwen3-native track tower. | |
| print(f"[tower] {encoder_name!r} → Qwen3-native metadata tower (1024-d)") | |
| tower = load_qwen_track_tower(QWEN_TOWER_CACHE, QWEN_MODALITY) | |
| return ( | |
| tower.embeddings[QWEN_MODALITY], | |
| tower.masks[QWEN_MODALITY], | |
| tower.id_to_idx, | |
| ) | |
| else: | |
| # Legacy: qwen3_frozen, keyword_*_qwen3 output 1024-d organizer Qwen3 vectors. | |
| print(f"[tower] {encoder_name!r} → organizer Qwen3 metadata tower (1024-d, legacy)") | |
| tower = load_track_tower( | |
| shards_dir=DATA / "TalkPlayData-Challenge-Track-Embeddings/data", | |
| modalities=[LEGACY_QWEN3_MODALITY], cache_dir=TOWER_CACHE, | |
| ) | |
| return ( | |
| tower.embeddings[LEGACY_QWEN3_MODALITY], | |
| tower.masks[LEGACY_QWEN3_MODALITY], | |
| tower.id_to_idx, | |
| ) | |
| print(f"[tower] {encoder_name!r} → {backbone!r} text track tower (768-d)") | |
| tower = load_text_track_tower(backbone, cache_dir=TEXT_TOWER_CACHE) | |
| modality = get_text_modality(backbone) | |
| return tower.embeddings[modality], tower.masks[modality], tower.id_to_idx | |
| def main(): | |
| p = argparse.ArgumentParser() | |
| p.add_argument("--encoder", required=True, | |
| help="Cache name under models/query_emb_cache/, e.g. " | |
| "qwen3_native_frozen, qwen3_lora__qwen3_lora_routing, " | |
| "bert_native_frozen, keyword_modernbert_qwen3.") | |
| p.add_argument("--split", default="val", | |
| choices=["val", "test", "dev", "blind_a"]) | |
| p.add_argument("--ks", type=int, nargs="+", default=list(DEFAULT_KS)) | |
| p.add_argument("--no-mask-played", action="store_true") | |
| args = p.parse_args() | |
| conv_split = FOLD_TO_CONV_SPLIT[args.split] | |
| qcache = QUERY_CACHE / args.encoder | |
| q_emb_path = qcache / f"{conv_split}.npy" | |
| meta_path = qcache / f"{conv_split}_meta.parquet" | |
| if not q_emb_path.exists(): | |
| raise FileNotFoundError( | |
| f"No cached queries at {q_emb_path}. " | |
| f"Run 03_encode_queries.py --encoder {args.encoder} --splits {conv_split} first." | |
| ) | |
| q_emb = np.load(q_emb_path) | |
| meta_df = pl.read_parquet(meta_path) | |
| print(f"queries: {q_emb.shape}, meta rows: {meta_df.shape[0]} " | |
| f"(fold={args.split}, conv_split={conv_split})") | |
| # ── For val/test: subset to the pinned predict-turn rows of the fold ── | |
| if args.split in ("val", "test"): | |
| if not SPLITS_PATH.exists(): | |
| raise FileNotFoundError( | |
| f"{SPLITS_PATH} not found. Run scripts/01b_rebuild_split.py first." | |
| ) | |
| split_df = load_blinda_split(SPLITS_PATH) | |
| pairs = turn_pairs_for_fold(split_df, args.split) | |
| idx = select_pair_indices(meta_df, pairs) | |
| if not idx: | |
| raise ValueError( | |
| f"No rows in {meta_path} match the {args.split} (session_id, turn) pairs. " | |
| f"Check that 03_encode_queries.py was run on the 'train' split and that " | |
| f"predict_turn_number aligns with meta turn_number." | |
| ) | |
| idx_arr = np.asarray(idx, dtype=np.int64) | |
| q_emb = q_emb[idx_arr] | |
| meta_df = ( | |
| meta_df.with_row_index(name="__row") | |
| .filter(pl.col("__row").is_in(idx)) | |
| .drop("__row") | |
| ) | |
| print(f" subset to {q_emb.shape[0]} predict-turn rows for fold {args.split!r}") | |
| track_emb, track_mask, id_to_idx = load_tower_for_encoder(args.encoder) | |
| print(f"track tower: {track_emb.shape} mask coverage {track_mask.mean():.3f}") | |
| if track_emb.shape[1] != q_emb.shape[1]: | |
| raise ValueError( | |
| f"DIM MISMATCH: queries D={q_emb.shape[1]} vs track tower D={track_emb.shape[1]}.\n" | |
| f" encoder cache: {args.encoder}\n" | |
| f" This usually means the encoder was trained/encoded against a different " | |
| f"tower than the one being loaded now. Re-encode with 03_encode_queries.py " | |
| f"and (for LoRA) re-train with 05_train_encoder.py." | |
| ) | |
| max_k = max(args.ks) | |
| topk = compute_topk(q_emb, track_emb, track_mask, meta_df, id_to_idx, | |
| max_k=max_k, mask_played=not args.no_mask_played) | |
| report = compute_recall(topk, meta_df, id_to_idx, ks=tuple(args.ks)) | |
| out_dir = EVAL_OUT / args.encoder / args.split | |
| save_report(report, out_dir, encoder_name=args.encoder) | |
| save_heatmaps(report, out_dir, encoder_name=args.encoder) | |
| if __name__ == "__main__": | |
| main() |