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