NicoloLocatelli's picture
Add files using upload-large-folder tool
fb39d9b verified
Raw History Blame Contribute Delete
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()