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()