Download src/heuristic/scripts/03_encode_queries.py from NicoloLocatelli/RecSys_ACM_2026_Hallucinated: direct link, hf CLI and curl.
- Browser
- Download file 9.08 kB
-
https://huggingface.co/datasets/NicoloLocatelli/RecSys_ACM_2026_Hallucinated/resolve/main/src/heuristic/scripts/03_encode_queries.py
- Command line
-
hf download hf://datasets/NicoloLocatelli/RecSys_ACM_2026_Hallucinated/src/heuristic/scripts/03_encode_queries.py
-
curl -L -o 03_encode_queries.py https://huggingface.co/datasets/NicoloLocatelli/RecSys_ACM_2026_Hallucinated/resolve/main/src/heuristic/scripts/03_encode_queries.py
9.08 kB
| """Encode queries with the chosen encoder and cache to disk. | |
| Usage: | |
| python scripts/03_encode_queries.py --encoder qwen3_frozen --splits train dev blind_a | |
| python scripts/03_encode_queries.py --encoder qwen3_lora --adapter <ckpt> --splits dev | |
| python scripts/03_encode_queries.py --encoder bert_proj_lora_routing --adapter <ckpt> --splits dev | |
| python scripts/03_encode_queries.py --encoder bert_native_frozen --splits dev | |
| python scripts/03_encode_queries.py --encoder keyword_bert_qwen3 --splits dev | |
| Cache layout (per encoder + adapter): | |
| models/query_emb_cache/<name>/<split>.npy | |
| models/query_emb_cache/<name>/<split>_meta.parquet | |
| where <name> = encoder if no adapter, else encoder__adapter_basename. | |
| Query text: built by `build_query_text_v2`, which drops noise fields (raw age, | |
| gender, country_name, category/specificity enum labels, goal_progress | |
| assessments, assistant content) and resolves prior-track ids to lines that | |
| look like track-tower entries via the `track_lookup` we load below. | |
| """ | |
| from __future__ import annotations | |
| import argparse | |
| import sys | |
| from collections import defaultdict | |
| from pathlib import Path | |
| import numpy as np | |
| import polars as pl | |
| import torch | |
| from tqdm import tqdm | |
| sys.path.insert(0, str(Path(__file__).resolve().parents[1])) | |
| from scripts._encoders_factory import build_encoder | |
| # emblib was reorganized under emblib.old.* — these helpers live there now. | |
| from emblib.old.data.parsing import build_query_text_v2 | |
| from emblib.old.data.user_features import load_user_features | |
| from emblib.old.encoders.base import encode_corpus | |
| # Resolve data/models against the REPO ROOT (parents[3]: scripts → src/heuristic | |
| # → src → repo), NOT the cwd — this script runs from the embeddings-package venv | |
| # but reads/writes the repo's real data/ and models/. | |
| _REPO = Path(__file__).resolve().parents[3] | |
| DATA = _REPO / "data" / "talkpl-ai" | |
| OUT_BASE = _REPO / "models" / "query_emb_cache" | |
| USER_CACHE = _REPO / "models" / "user_features_cache" | |
| TRACK_META = DATA / "TalkPlayData-Challenge-Track-Metadata/data/all_tracks-00000-of-00001.parquet" | |
| import os # noqa: E402 | |
| SPLIT_TO_PARQUET = { | |
| "train": DATA / "TalkPlayData-Challenge-Dataset/data/train-00000-of-00001.parquet", | |
| "dev": DATA / "TalkPlayData-Challenge-Dataset/data/test-00000-of-00001.parquet", | |
| "blind_a": DATA / "TalkPlayData-Challenge-Blind-A/data/test-00000-of-00001.parquet", | |
| } | |
| SPLIT_TO_PARQUET[os.environ.get("BLINDB_SPLIT", "blind_b")] = Path(os.environ.get( | |
| "BLINDB_PARQUET", | |
| str(DATA.parent / "talkpl-ai" / "TalkPlayData-Challenge-Blind-B" / "data" / "test-00000-of-00001.parquet"))) | |
| META_SCHEMA = { | |
| "session_id": pl.String, "user_id": pl.String, "turn_number": pl.Int64, | |
| "gt_track_id": pl.String, "category": pl.String, "specificity": pl.String, | |
| "prior_track_ids": pl.List(pl.String), | |
| } | |
| def load_track_lookup(track_meta_path: Path) -> dict[str, dict]: | |
| """Build a track_id -> metadata-row dict for v2's [PLAYED] line resolution. | |
| The lookup is keyed by track_id; each value is the full track-metadata | |
| parquet row (track_name, artist_name, tag_list, release_date, ...). It | |
| is read once per script invocation (~47k entries, ~50 MB of dict overhead). | |
| """ | |
| print(f"Loading track lookup from {track_meta_path}") | |
| md = pl.read_parquet(track_meta_path) | |
| lookup = {row["track_id"]: row for row in md.to_dicts()} | |
| print(f" {len(lookup)} tracks indexed") | |
| return lookup | |
| def parse_session(item: dict, track_lookup: dict[str, dict]): | |
| """Convert one raw session row into one query-row per assistant turn. | |
| The query text is built by `build_query_text_v2`, which: | |
| - drops raw age, gender, country_name, category/specificity enum labels, | |
| goal_progress assessments, and assistant `content`; | |
| - keeps preferred_musical_culture, age_group, listener_goal, chat history | |
| thoughts, and the current user message; | |
| - injects `[PLAYED]` lines (resolved name+artist+tags+year via | |
| track_lookup) and a `[SESSION] year=YYYY` line; | |
| - lays out the prompt so the always-survives block (profile, goal, | |
| session, current-user) is at the bottom and survives left-truncation. | |
| """ | |
| convs = item["conversations"] | |
| user_profile = item.get("user_profile") or {} | |
| conv_goal = item.get("conversation_goal") or {} | |
| cat = (conv_goal.get("category") or "") | |
| spec = (conv_goal.get("specificity") or "") | |
| session_date = item.get("session_date") | |
| if session_date is not None: | |
| session_date = str(session_date) | |
| turns_by_number = defaultdict(list) | |
| for t in convs: | |
| turns_by_number[t["turn_number"]].append(t) | |
| rows = [] | |
| for tn in sorted(turns_by_number.keys()): | |
| user_msgs = [t for t in turns_by_number[tn] if t["role"] == "user"] | |
| if not user_msgs: | |
| continue | |
| music_msgs = [t for t in turns_by_number[tn] if t["role"] == "music"] | |
| gt = music_msgs[0]["content"] if music_msgs else None | |
| chat_history, prior_ids = [], [] | |
| for t_ in sorted(turns_by_number.keys()): | |
| if t_ >= tn: | |
| break | |
| for prev in turns_by_number[t_]: | |
| chat_history.append({ | |
| "role": prev.get("role"), | |
| "content": prev.get("content") or "", | |
| "thought": prev.get("thought") or "", | |
| }) | |
| if prev.get("role") == "music" and prev.get("content"): | |
| prior_ids.append(prev["content"]) | |
| text = build_query_text_v2( | |
| chat_history=chat_history, | |
| user_query=user_msgs[0]["content"], | |
| user_profile=user_profile, | |
| conversation_goal=conv_goal, | |
| session_date=session_date, | |
| track_lookup=track_lookup, | |
| use_thoughts=True, | |
| ) | |
| rows.append({ | |
| "session_id": item["session_id"], "user_id": item["user_id"], | |
| "turn_number": tn, "gt_track_id": gt, | |
| "category": cat, "specificity": spec, | |
| "prior_track_ids": prior_ids, "query_text": text, | |
| }) | |
| return rows | |
| def main(): | |
| p = argparse.ArgumentParser() | |
| p.add_argument("--encoder", required=True) | |
| p.add_argument("--adapter", type=Path, default=None, | |
| help="Required for qwen3_lora and *_proj_* encoders.") | |
| p.add_argument("--splits", nargs="+", default=["train", "dev", "blind_a"]) | |
| p.add_argument("--batch-size", type=int, default=16) | |
| args = p.parse_args() | |
| cache_name = args.encoder | |
| if args.adapter is not None: | |
| cache_name = f"{args.encoder}__{args.adapter.name}" | |
| out_dir = OUT_BASE / cache_name | |
| out_dir.mkdir(parents=True, exist_ok=True) | |
| device = torch.device("cuda" if torch.cuda.is_available() else "cpu") | |
| encoder = build_encoder(args.encoder, args.adapter).to(device) | |
| users = load_user_features( | |
| user_meta_path=DATA / "TalkPlayData-Challenge-User-Metadata/data/all_users-00000-of-00001.parquet", | |
| user_emb_train_path=DATA / "TalkPlayData-Challenge-User-Embeddings/data/train-00000-of-00001.parquet", | |
| user_emb_warm_path=DATA / "TalkPlayData-Challenge-User-Embeddings/data/test_warm-00000-of-00001.parquet", | |
| user_emb_cold_path=DATA / "TalkPlayData-Challenge-User-Embeddings/data/test_cold-00000-of-00001.parquet", | |
| cache_dir=USER_CACHE, | |
| ) | |
| track_lookup = load_track_lookup(TRACK_META) | |
| for split in args.splits: | |
| path = SPLIT_TO_PARQUET.get(split) | |
| if path is None or not path.exists(): | |
| print(f"[skip] {split}: {path} missing"); continue | |
| print(f"\n=== {split} ===") | |
| df = pl.read_parquet(path) | |
| rows = [] | |
| for item in tqdm(df.to_dicts(), desc=f"parse {split}"): | |
| rows.extend(parse_session(item, track_lookup)) | |
| print(f" {len(rows)} (session, turn) rows") | |
| n = len(rows) | |
| u_cf = np.zeros((n, users.cf.shape[1]), dtype=np.float32) | |
| is_cold = np.ones(n, dtype=bool) | |
| for i, r in enumerate(rows): | |
| uid = r["user_id"] | |
| if uid in users.id_to_idx: | |
| u_idx = users.id_to_idx[uid] | |
| u_cf[i] = users.cf[u_idx] | |
| is_cold[i] = bool(users.is_cold[u_idx]) | |
| emb = encode_corpus(encoder, [r["query_text"] for r in rows], | |
| u_cf, is_cold, batch_size=args.batch_size) | |
| np.save(out_dir / f"{split}.npy", emb) | |
| meta_df = pl.DataFrame({ | |
| "session_id": [r["session_id"] for r in rows], | |
| "user_id": [r["user_id"] for r in rows], | |
| "turn_number": [r["turn_number"] for r in rows], | |
| "gt_track_id": [r["gt_track_id"] for r in rows], | |
| "category": [r["category"] for r in rows], | |
| "specificity": [r["specificity"] for r in rows], | |
| "prior_track_ids": [r["prior_track_ids"] for r in rows], | |
| }, schema=META_SCHEMA) | |
| meta_df.write_parquet(out_dir / f"{split}_meta.parquet") | |
| print(f" wrote {emb.shape} -> {out_dir}") | |
| if __name__ == "__main__": | |
| main() |