File size: 9,084 Bytes
1a6af84 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 | """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() |