File size: 14,200 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
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
"""3-way split (train_proj / train_rerank / val) — v2.



Improvements over v1:

  1. Softer cutoff (default 2017-01-01) — gives more candidate sessions for

     the holdout while still preserving the temporal property:

     no train_proj session is dated AFTER the latest val session.

  2. Stratification by user warmth (warm/cold in cf-bpr): the simulated-cold

     rate is computed among WARM users only, so the holdout's real-cold rate

     matches dev's 25.8% target rather than 26% of everyone.

  3. Stratification by dominant (category, specificity): inside the holdout

     pool, users are bucketed by their most frequent goal pair and sampled

     proportionally so train_rerank and val have similar category mixes.

  4. Quota-based selection rather than greedy: each stratum gets an integer

     session quota, and users are picked deterministically by hash within

     each stratum until the quota is met.



Output: models/splits/train_val.parquet with columns

  session_id, user_id, split, simulate_cold



Run:

    uv run python -m scripts.launchers.make_train_val_split_v2 \\

        --cutoff-date 2017-01-01

"""
from __future__ import annotations

import argparse
import hashlib
from collections import defaultdict, Counter
from pathlib import Path

import polars as pl


#DATA           = Path("./data/talkpl-ai")
# TRAIN_PARQUET  = DATA / "TalkPlayData-Challenge-Dataset/data/train-00000-of-00001.parquet"
# DEV_PARQUET    = DATA / "TalkPlayData-Challenge-Dataset/data/test-00000-of-00001.parquet"
# USER_EMB_TRAIN = DATA / "TalkPlayData-Challenge-User-Embeddings/data/train-00000-of-00001.parquet"
#OUT            = Path("./models/splits/train_val.parquet")

PKG  = Path(__file__).resolve().parents[1]
REPO = Path(__file__).resolve().parents[3]
DATA = REPO / "data/talkpl-ai"                       # was Path("./data/talkpl-ai")
TRAIN_PARQUET  = DATA / "TalkPlayData-Challenge-Dataset/data/train-00000-of-00001.parquet"
DEV_PARQUET    = DATA / "TalkPlayData-Challenge-Dataset/data/test-00000-of-00001.parquet"
USER_EMB_TRAIN = DATA / "TalkPlayData-Challenge-User-Embeddings/data/train-00000-of-00001.parquet"
OUT  = PKG / "models/splits/train_val.parquet"       # was Path("./models/splits/..."


def hash_bucket(key: str, seed: int, mod: int = 100000) -> int:
    """Deterministic uniform hash of a string key into [0, mod)."""
    h = hashlib.sha256(f"{seed}:{key}".encode()).hexdigest()
    return int(h[:8], 16) % mod


def load_session_metadata(train_parquet: Path) -> pl.DataFrame:
    """Pull session_id, user_id, session_date, dominant (cat, spec) per session."""
    print(f"Loading {train_parquet}")
    full = pl.read_parquet(train_parquet)
    rows = []
    for r in full.to_dicts():
        cg = r.get("conversation_goal") or {}
        rows.append({
            "session_id":   r["session_id"],
            "user_id":      r["user_id"],
            "session_date": str(r["session_date"]),
            "category":     cg.get("category") or "?",
            "specificity":  cg.get("specificity") or "?",
        })
    return pl.DataFrame(rows)


def load_warm_users(user_emb_train: Path) -> set[str]:
    """Users that have a non-empty cf-bpr embedding (i.e. real warm users)."""
    if not user_emb_train.exists():
        print(f"  WARNING: {user_emb_train} missing — assuming all users warm.")
        return set()
    df = pl.read_parquet(user_emb_train)
    warm = set()
    for r in df.to_dicts():
        v = r.get("cf-bpr")
        if v is not None and len(v) > 0:
            warm.add(r["user_id"])
    return warm


def dominant_pair_per_user(sessions: pl.DataFrame) -> dict[str, tuple[str, str]]:
    """For each user, find the most common (category, specificity) pair.

    Ties broken by alphabetical stability."""
    cnt: dict[str, Counter] = defaultdict(Counter)
    for r in sessions.iter_rows(named=True):
        cnt[r["user_id"]][(r["category"], r["specificity"])] += 1
    return {
        uid: max(c.items(), key=lambda kv: (kv[1], kv[0]))[0]
        for uid, c in cnt.items()
    }


def sessions_per_user(sessions: pl.DataFrame) -> dict[str, int]:
    return dict(zip(
        sessions.group_by("user_id").len()["user_id"].to_list(),
        sessions.group_by("user_id").len()["len"].to_list(),
    ))


def stratified_quota_sample(

    candidates_by_stratum: dict[tuple, list[str]],

    sessions_per_user_map: dict[str, int],

    target_total_sessions: int,

    seed: int,

) -> set[str]:
    """Pick users from each stratum proportional to its share of sessions in

    `candidates_by_stratum`, until target_total_sessions is approximately reached.



    Within each stratum, users are sorted by hash_bucket and taken in order so

    the choice is deterministic for a given seed.

    """
    strata_session_count = {
        stratum: sum(sessions_per_user_map[u] for u in users)
        for stratum, users in candidates_by_stratum.items()
    }
    total_pool_sessions = sum(strata_session_count.values())
    if total_pool_sessions == 0:
        return set()

    chosen: set[str] = set()
    chosen_sessions = 0
    # Per-stratum target (round half-up)
    for stratum, users in candidates_by_stratum.items():
        share = strata_session_count[stratum] / total_pool_sessions
        stratum_target = int(round(target_total_sessions * share))
        if stratum_target == 0:
            continue
        ordered = sorted(users, key=lambda u: hash_bucket(u, seed + 7))
        taken_sessions = 0
        for u in ordered:
            if taken_sessions >= stratum_target:
                break
            chosen.add(u)
            taken_sessions += sessions_per_user_map[u]
            chosen_sessions += sessions_per_user_map[u]
    return chosen


def main():
    p = argparse.ArgumentParser()
    p.add_argument("--rerank-fraction", type=float, default=0.16)
    p.add_argument("--val-fraction", type=float, default=0.20)
    p.add_argument(
        "--cutoff-date", type=str, default="2017-01-01",
        help="Sessions on/after this date are eligible for train_rerank/val. "
             "Softer than the v1 default (2018-01-01) so the holdout has a "
             "richer distribution of session dates. Anything BEFORE the cutoff "
             "stays in train_proj, which preserves temporal causality.",
    )
    p.add_argument("--cold-fraction", type=float, default=0.26,
                   help="Fraction of WARM holdout users to mark simulate_cold. "
                        "Real cold users are already cold; this dials the holdout's "
                        "effective cold rate to match dev's 25.8%.")
    p.add_argument("--seed", type=int, default=42)
    p.add_argument("--no-stratify-category", action="store_true",
                   help="Skip (category, specificity) stratification (not recommended).")
    args = p.parse_args()

    if args.rerank_fraction + args.val_fraction >= 1.0:
        raise ValueError("rerank-fraction + val-fraction must be < 1.0")

    # ── Load core tables ─────────────────────────────────────────────────────
    sessions = load_session_metadata(TRAIN_PARQUET)
    n_total = sessions.shape[0]
    n_users = sessions["user_id"].n_unique()
    print(f"  {n_total} sessions, {n_users} users")

    cutoff = args.cutoff_date
    n_after = sessions.filter(pl.col("session_date") >= cutoff).shape[0]
    print(f"  cutoff={cutoff}  post-cutoff sessions: {n_after} ({n_after/n_total:.3f})")

    warm_users = load_warm_users(USER_EMB_TRAIN)
    print(f"  warm users (have cf-bpr): {len(warm_users)} / {n_users} "
          f"({len(warm_users)/max(n_users,1):.3f})")

    spu = sessions_per_user(sessions)
    dom_pair = dominant_pair_per_user(sessions)

    # ── Holdout eligibility: user's LATEST session must be on/after cutoff ──
    user_latest = (
        sessions
        .group_by("user_id")
        .agg(pl.col("session_date").max().alias("latest"))
    )
    eligible_users = set(
        user_latest.filter(pl.col("latest") >= cutoff)["user_id"].to_list()
    )
    print(f"  holdout-eligible users (latest session ≥ cutoff): {len(eligible_users)}")

    # ── Stratified sampling of holdout users ─────────────────────────────────
    target_holdout = int(n_total * (args.rerank_fraction + args.val_fraction))
    print(f"  target holdout sessions: {target_holdout}")

    if args.no_stratify_category:
        print("  category stratification: OFF")
        candidates_by_stratum = {("ALL", "ALL"): list(eligible_users)}
    else:
        # One stratum per (warm, dominant_category, dominant_specificity) bucket.
        # warm/cold included so we balance both axes simultaneously.
        candidates_by_stratum: dict[tuple, list[str]] = defaultdict(list)
        for u in eligible_users:
            warm_flag = "W" if u in warm_users else "C"
            cat, spec = dom_pair.get(u, ("?", "?"))
            candidates_by_stratum[(warm_flag, cat, spec)].append(u)
        print(f"  category strata: {len(candidates_by_stratum)} buckets "
              f"(warm/cold × cat × spec)")

    holdout_users = stratified_quota_sample(
        candidates_by_stratum, spu, target_holdout, args.seed,
    )
    holdout_sessions = sum(spu[u] for u in holdout_users)
    print(f"  selected holdout: {len(holdout_users)} users, {holdout_sessions} sessions "
          f"({holdout_sessions/n_total:.3f} of total — target {target_holdout/n_total:.3f})")

    # ── Within holdout, split rerank vs val proportionally per stratum ──────
    rerank_share = args.rerank_fraction / (args.rerank_fraction + args.val_fraction)
    rerank_threshold = int(rerank_share * 100000)
    rerank_users = {
        u for u in holdout_users
        if hash_bucket(u, args.seed + 2) < rerank_threshold
    }
    val_users = holdout_users - rerank_users

    rerank_sessions = sum(spu[u] for u in rerank_users)
    val_sessions = sum(spu[u] for u in val_users)
    print(f"  rerank: {len(rerank_users)} users, {rerank_sessions} sessions "
          f"({rerank_sessions/n_total:.3f})")
    print(f"  val:    {len(val_users)} users, {val_sessions} sessions "
          f"({val_sessions/n_total:.3f})")

    # ── Cold simulation: only on WARM holdout users ─────────────────────────
    warm_holdout = holdout_users & warm_users
    cold_threshold = int(args.cold_fraction * 100000)
    simulate_cold_users = {
        u for u in warm_holdout
        if hash_bucket(u, args.seed + 1) < cold_threshold
    }
    print(f"  marked {len(simulate_cold_users)}/{len(warm_holdout)} WARM holdout "
          f"users as simulate_cold (target {args.cold_fraction:.2f}, "
          f"actual {len(simulate_cold_users)/max(len(warm_holdout),1):.3f})")

    real_cold = len(holdout_users) - len(warm_holdout)
    effective_cold = real_cold + len(simulate_cold_users)
    print(f"  effective cold rate in holdout: {effective_cold/max(len(holdout_users),1):.3f} "
          f"(real {real_cold} + simulated {len(simulate_cold_users)})")

    # ── Write output ─────────────────────────────────────────────────────────
    rows = []
    for r in sessions.iter_rows(named=True):
        uid = r["user_id"]
        if uid in rerank_users:
            split = "train_rerank"
        elif uid in val_users:
            split = "val"
        else:
            split = "train_proj"
        rows.append({
            "session_id":    r["session_id"],
            "user_id":       uid,
            "split":         split,
            "simulate_cold": (split != "train_proj") and (uid in simulate_cold_users),
        })
    out_df = pl.DataFrame(rows)

    # ── Diagnostics + final assertions ──────────────────────────────────────
    print(f"\nFinal split counts:")
    print(out_df.group_by("split").len().sort("split"))

    proj_users = set(out_df.filter(pl.col("split") == "train_proj")["user_id"].to_list())
    assert len(proj_users & rerank_users) == 0, "train_proj ∩ rerank not empty"
    assert len(proj_users & val_users) == 0,    "train_proj ∩ val not empty"
    assert len(rerank_users & val_users) == 0,  "rerank ∩ val not empty"
    print("User-disjointness: OK")

    # Temporal causality check
    proj_sessions = sessions.filter(pl.col("user_id").is_in(proj_users))
    rerank_sessions_df = sessions.filter(pl.col("user_id").is_in(rerank_users))
    val_sessions_df = sessions.filter(pl.col("user_id").is_in(val_users))
    if rerank_sessions_df.shape[0]:
        max_proj = proj_sessions["session_date"].max()
        min_rerank = rerank_sessions_df["session_date"].min()
        min_val = val_sessions_df["session_date"].min() if val_sessions_df.shape[0] else None
        print(f"\nTemporal causality:")
        print(f"  train_proj: {proj_sessions['session_date'].min()} .. {max_proj}")
        print(f"  rerank:     {min_rerank} .. {rerank_sessions_df['session_date'].max()}")
        if min_val:
            print(f"  val:        {min_val} .. {val_sessions_df['session_date'].max()}")
        # The cutoff we used guarantees: max(train_proj) ≤ cutoff ≤ min(rerank, val)
        print(f"  cutoff was {cutoff}; max(train_proj)={max_proj}, "
              f"min(rerank)={min_rerank}, min(val)={min_val}")

    if DEV_PARQUET.exists():
        dev_dates = pl.read_parquet(DEV_PARQUET, columns=["session_date"])["session_date"].sort()
        print(f"  dev (reference): {dev_dates[0]} .. {dev_dates[-1]}")

    OUT.parent.mkdir(parents=True, exist_ok=True)
    out_df.write_parquet(OUT)
    print(f"\nWrote {OUT}")


if __name__ == "__main__":
    main()